diff --git a/Source/Core/Core/Core.cpp b/Source/Core/Core/Core.cpp
index afadd1fde8..f6cbb10d4a 100644
--- a/Source/Core/Core/Core.cpp
+++ b/Source/Core/Core/Core.cpp
@@ -660,7 +660,7 @@ static void EmuThread(std::unique_ptr<BootParameters> boot, WindowSystemInfo wsi
     wiifs_guard.Dismiss();
 
   // This adds the SyncGPU handler to CoreTiming, so now CoreTiming::Advance might block.
-  system.GetFifo().Prepare(system);
+  system.GetFifo().Prepare();
 
   // Setup our core
   if (Config::Get(Config::MAIN_CPU_CORE) != PowerPC::CPUCore::Interpreter)
@@ -687,7 +687,7 @@ static void EmuThread(std::unique_ptr<BootParameters> boot, WindowSystemInfo wsi
     s_cpu_thread = std::thread(cpuThreadFunc, savestate_path, delete_savestate);
 
     // become the GPU thread
-    system.GetFifo().RunGpuLoop(system);
+    system.GetFifo().RunGpuLoop();
 
     // We have now exited the Video Loop
     INFO_LOG_FMT(CONSOLE, "{}", StopMessage(false, "Video Loop Ended"));
@@ -834,7 +834,7 @@ static bool PauseAndLock(Core::System& system, bool do_lock, bool unpause_on_unl
 
   // video has to come after CPU, because CPU thread can wait for video thread
   // (s_efbAccessRequested).
-  system.GetFifo().PauseAndLock(system, do_lock, false);
+  system.GetFifo().PauseAndLock(do_lock, false);
 
   ResetRumble();
 
@@ -1029,7 +1029,7 @@ void UpdateWantDeterminism(bool initial)
         ios->UpdateWantDeterminism(new_want_determinism);
 
       auto& system = Core::System::GetInstance();
-      system.GetFifo().UpdateWantDeterminism(system, new_want_determinism);
+      system.GetFifo().UpdateWantDeterminism(new_want_determinism);
 
       // We need to clear the cache because some parts of the JIT depend on want_determinism,
       // e.g. use of FMA.
diff --git a/Source/Core/Core/CoreTiming.cpp b/Source/Core/Core/CoreTiming.cpp
index 945cc31bc8..627f14cbce 100644
--- a/Source/Core/Core/CoreTiming.cpp
+++ b/Source/Core/Core/CoreTiming.cpp
@@ -466,17 +466,15 @@ void CoreTimingManager::AdjustEventQueueTimes(u32 new_ppc_clock, u32 old_ppc_clo
 
 void CoreTimingManager::Idle()
 {
-  auto& system = m_system;
-  auto& ppc_state = m_system.GetPPCState();
-
   if (m_config_sync_on_skip_idle)
   {
     // When the FIFO is processing data we must not advance because in this way
     // the VI will be desynchronized. So, We are waiting until the FIFO finish and
     // while we process only the events required by the FIFO.
-    system.GetFifo().FlushGpu(system);
+    m_system.GetFifo().FlushGpu();
   }
 
+  auto& ppc_state = m_system.GetPPCState();
   PowerPC::UpdatePerformanceMonitor(ppc_state.downcount, 0, 0, ppc_state);
   m_idled_cycles += DowncountToCycles(ppc_state.downcount);
   ppc_state.downcount = 0;
diff --git a/Source/Core/Core/System.cpp b/Source/Core/Core/System.cpp
index e35d06c54f..d49542a07b 100644
--- a/Source/Core/Core/System.cpp
+++ b/Source/Core/Core/System.cpp
@@ -42,9 +42,9 @@ struct System::Impl
 {
   explicit Impl(System& system)
       : m_audio_interface(system), m_core_timing(system), m_cpu(system), m_dsp(system),
-        m_dvd_interface(system), m_dvd_thread(system), m_expansion_interface(system),
-        m_gp_fifo(system), m_memory(system), m_power_pc(system),
-        m_mmu(system, m_memory, m_power_pc), m_processor_interface(system),
+        m_dvd_interface(system), m_dvd_thread(system),
+        m_expansion_interface(system), m_fifo{system}, m_gp_fifo(system), m_memory(system),
+        m_power_pc(system), m_mmu(system, m_memory, m_power_pc), m_processor_interface(system),
         m_serial_interface(system), m_video_interface(system),
         m_interpreter(system, m_power_pc.GetPPCState(), m_mmu), m_jit_interface(system)
   {
diff --git a/Source/Core/DolphinQt/Host.cpp b/Source/Core/DolphinQt/Host.cpp
index ca87f83d4c..c7f7c1d6fb 100644
--- a/Source/Core/DolphinQt/Host.cpp
+++ b/Source/Core/DolphinQt/Host.cpp
@@ -106,9 +106,9 @@ static void RunWithGPUThreadInactive(std::function<void()> f)
     const bool was_running = Core::GetState() == Core::State::Running;
     auto& system = Core::System::GetInstance();
     auto& fifo = system.GetFifo();
-    fifo.PauseAndLock(system, true, was_running);
+    fifo.PauseAndLock(true, was_running);
     f();
-    fifo.PauseAndLock(system, false, was_running);
+    fifo.PauseAndLock(false, was_running);
   }
   else
   {
diff --git a/Source/Core/VideoCommon/AsyncRequests.cpp b/Source/Core/VideoCommon/AsyncRequests.cpp
index ad854a3dce..92c06f0b90 100644
--- a/Source/Core/VideoCommon/AsyncRequests.cpp
+++ b/Source/Core/VideoCommon/AsyncRequests.cpp
@@ -96,7 +96,7 @@ void AsyncRequests::PushEvent(const AsyncRequests::Event& event, bool blocking)
   m_queue.push(event);
 
   auto& system = Core::System::GetInstance();
-  system.GetFifo().RunGpu(system);
+  system.GetFifo().RunGpu();
   if (blocking)
   {
     m_cond.wait(lock, [this] { return m_queue.empty(); });
diff --git a/Source/Core/VideoCommon/CommandProcessor.cpp b/Source/Core/VideoCommon/CommandProcessor.cpp
index 70682941df..2713b33cbf 100644
--- a/Source/Core/VideoCommon/CommandProcessor.cpp
+++ b/Source/Core/VideoCommon/CommandProcessor.cpp
@@ -224,7 +224,7 @@ void CommandProcessorManager::RegisterMMIO(Core::System& system, MMIO::Mapping*
 
   mmio->Register(base | STATUS_REGISTER, MMIO::ComplexRead<u16>([](Core::System& system_, u32) {
                    auto& cp = system_.GetCommandProcessor();
-                   system_.GetFifo().SyncGPUForRegisterAccess(system_);
+                   system_.GetFifo().SyncGPUForRegisterAccess();
                    cp.SetCpStatusRegister(system_);
                    return cp.m_cp_status_reg.Hex;
                  }),
@@ -236,7 +236,7 @@ void CommandProcessorManager::RegisterMMIO(Core::System& system, MMIO::Mapping*
                    UCPCtrlReg tmp(val);
                    cp.m_cp_ctrl_reg.Hex = tmp.Hex;
                    cp.SetCpControlRegister(system_);
-                   system_.GetFifo().RunGpu(system_);
+                   system_.GetFifo().RunGpu();
                  }));
 
   mmio->Register(base | CLEAR_REGISTER, MMIO::DirectRead<u16>(&m_cp_clear_reg.Hex),
@@ -245,7 +245,7 @@ void CommandProcessorManager::RegisterMMIO(Core::System& system, MMIO::Mapping*
                    UCPClearReg tmp(val);
                    cp.m_cp_clear_reg.Hex = tmp.Hex;
                    cp.SetCpClearRegister();
-                   system_.GetFifo().RunGpu(system_);
+                   system_.GetFifo().RunGpu();
                  }));
 
   mmio->Register(base | PERF_SELECT, MMIO::InvalidRead<u16>(), MMIO::Nop<u16>());
@@ -285,7 +285,7 @@ void CommandProcessorManager::RegisterMMIO(Core::System& system, MMIO::Mapping*
   {
     fifo_rw_distance_hi_r = MMIO::ComplexRead<u16>([](Core::System& system_, u32) {
       const auto& fifo_ = system_.GetCommandProcessor().GetFifo();
-      system_.GetFifo().SyncGPUForRegisterAccess(system_);
+      system_.GetFifo().SyncGPUForRegisterAccess();
       if (fifo_.CPWritePointer.load(std::memory_order_relaxed) >=
           fifo_.SafeCPReadPointer.load(std::memory_order_relaxed))
       {
@@ -307,16 +307,16 @@ void CommandProcessorManager::RegisterMMIO(Core::System& system, MMIO::Mapping*
   {
     fifo_rw_distance_hi_r = MMIO::ComplexRead<u16>([](Core::System& system_, u32) {
       const auto& fifo_ = system_.GetCommandProcessor().GetFifo();
-      system_.GetFifo().SyncGPUForRegisterAccess(system_);
+      system_.GetFifo().SyncGPUForRegisterAccess();
       return fifo_.CPReadWriteDistance.load(std::memory_order_relaxed) >> 16;
     });
   }
   mmio->Register(base | FIFO_RW_DISTANCE_HI, fifo_rw_distance_hi_r,
                  MMIO::ComplexWrite<u16>([WMASK_HI_RESTRICT](Core::System& system_, u32, u16 val) {
                    auto& fifo_ = system_.GetCommandProcessor().GetFifo();
-                   system_.GetFifo().SyncGPUForRegisterAccess(system_);
+                   system_.GetFifo().SyncGPUForRegisterAccess();
                    WriteHigh(fifo_.CPReadWriteDistance, val & WMASK_HI_RESTRICT);
-                   system_.GetFifo().RunGpu(system_);
+                   system_.GetFifo().RunGpu();
                  }));
 
   mmio->Register(
@@ -331,13 +331,13 @@ void CommandProcessorManager::RegisterMMIO(Core::System& system, MMIO::Mapping*
   {
     fifo_read_hi_r = MMIO::ComplexRead<u16>([](Core::System& system_, u32) {
       auto& fifo_ = system_.GetCommandProcessor().GetFifo();
-      system_.GetFifo().SyncGPUForRegisterAccess(system_);
+      system_.GetFifo().SyncGPUForRegisterAccess();
       return fifo_.SafeCPReadPointer.load(std::memory_order_relaxed) >> 16;
     });
     fifo_read_hi_w =
         MMIO::ComplexWrite<u16>([WMASK_HI_RESTRICT](Core::System& system_, u32, u16 val) {
           auto& fifo_ = system_.GetCommandProcessor().GetFifo();
-          system_.GetFifo().SyncGPUForRegisterAccess(system_);
+          system_.GetFifo().SyncGPUForRegisterAccess();
           WriteHigh(fifo_.CPReadPointer, val & WMASK_HI_RESTRICT);
           fifo_.SafeCPReadPointer.store(fifo_.CPReadPointer.load(std::memory_order_relaxed),
                                         std::memory_order_relaxed);
@@ -347,13 +347,13 @@ void CommandProcessorManager::RegisterMMIO(Core::System& system, MMIO::Mapping*
   {
     fifo_read_hi_r = MMIO::ComplexRead<u16>([](Core::System& system_, u32) {
       const auto& fifo_ = system_.GetCommandProcessor().GetFifo();
-      system_.GetFifo().SyncGPUForRegisterAccess(system_);
+      system_.GetFifo().SyncGPUForRegisterAccess();
       return fifo_.CPReadPointer.load(std::memory_order_relaxed) >> 16;
     });
     fifo_read_hi_w =
         MMIO::ComplexWrite<u16>([WMASK_HI_RESTRICT](Core::System& system_, u32, u16 val) {
           auto& fifo_ = system_.GetCommandProcessor().GetFifo();
-          system_.GetFifo().SyncGPUForRegisterAccess(system_);
+          system_.GetFifo().SyncGPUForRegisterAccess();
           WriteHigh(fifo_.CPReadPointer, val & WMASK_HI_RESTRICT);
         });
   }
@@ -379,10 +379,10 @@ void CommandProcessorManager::GatherPipeBursted(Core::System& system)
           (processor_interface.m_fifo_cpu_base == fifo.CPBase.load(std::memory_order_relaxed)) &&
           fifo.CPReadWriteDistance.load(std::memory_order_relaxed) > 0)
       {
-        system.GetFifo().FlushGpu(system);
+        system.GetFifo().FlushGpu();
       }
     }
-    system.GetFifo().RunGpu(system);
+    system.GetFifo().RunGpu();
     return;
   }
 
@@ -411,7 +411,7 @@ void CommandProcessorManager::GatherPipeBursted(Core::System& system)
 
   fifo.CPReadWriteDistance.fetch_add(GPFifo::GATHER_PIPE_SIZE, std::memory_order_seq_cst);
 
-  system.GetFifo().RunGpu(system);
+  system.GetFifo().RunGpu();
 
   ASSERT_MSG(COMMANDPROCESSOR,
              fifo.CPReadWriteDistance.load(std::memory_order_relaxed) <=
@@ -448,7 +448,7 @@ void CommandProcessorManager::UpdateInterrupts(Core::System& system, u64 userdat
   }
   system.GetCoreTiming().ForceExceptionCheck(0);
   m_interrupt_waiting.Clear();
-  system.GetFifo().RunGpu(system);
+  system.GetFifo().RunGpu();
 }
 
 void CommandProcessorManager::UpdateInterruptsFromVideoBackend(Core::System& system, u64 userdata)
@@ -616,7 +616,7 @@ void CommandProcessorManager::SetCpControlRegister(Core::System& system)
   if (fifo.bFF_GPReadEnable.load(std::memory_order_relaxed) && !m_cp_ctrl_reg.GPReadEnable)
   {
     fifo.bFF_GPReadEnable.store(m_cp_ctrl_reg.GPReadEnable, std::memory_order_relaxed);
-    system.GetFifo().FlushGpu(system);
+    system.GetFifo().FlushGpu();
   }
   else
   {
diff --git a/Source/Core/VideoCommon/Fifo.cpp b/Source/Core/VideoCommon/Fifo.cpp
index 3e6a6dd2ec..938990e182 100644
--- a/Source/Core/VideoCommon/Fifo.cpp
+++ b/Source/Core/VideoCommon/Fifo.cpp
@@ -36,7 +36,10 @@ namespace Fifo
 {
 static constexpr int GPU_TIME_SLOT_SIZE = 1000;
 
-FifoManager::FifoManager() = default;
+FifoManager::FifoManager(Core::System& system) : m_system{system}
+{
+}
+
 FifoManager::~FifoManager() = default;
 
 void FifoManager::RefreshConfig()
@@ -64,26 +67,26 @@ void FifoManager::DoState(PointerWrap& p)
   p.Do(m_syncing_suspended);
 }
 
-void FifoManager::PauseAndLock(Core::System& system, bool doLock, bool unpauseOnUnlock)
+void FifoManager::PauseAndLock(bool do_lock, bool unpause_on_unlock)
 {
-  if (doLock)
+  if (do_lock)
   {
     SyncGPU(SyncGPUReason::Other);
     EmulatorState(false);
 
-    if (!system.IsDualCoreMode() || m_use_deterministic_gpu_thread)
+    if (!m_system.IsDualCoreMode() || m_use_deterministic_gpu_thread)
       return;
 
     m_gpu_mainloop.WaitYield(std::chrono::milliseconds(100), Host_YieldToUI);
   }
   else
   {
-    if (unpauseOnUnlock)
+    if (unpause_on_unlock)
       EmulatorState(true);
   }
 }
 
-void FifoManager::Init(Core::System& system)
+void FifoManager::Init()
 {
   if (!m_config_callback_id)
     m_config_callback_id = Config::AddConfigChangedCallback([this] { RefreshConfig(); });
@@ -92,7 +95,7 @@ void FifoManager::Init(Core::System& system)
   // Padded so that SIMD overreads in the vertex loader are safe
   m_video_buffer = static_cast<u8*>(Common::AllocateMemoryPages(FIFO_SIZE + 4));
   ResetVideoBuffer();
-  if (system.IsDualCoreMode())
+  if (m_system.IsDualCoreMode())
     m_gpu_mainloop.Prepare();
   m_sync_ticks.store(0);
 }
@@ -120,14 +123,14 @@ void FifoManager::Shutdown()
 
 // May be executed from any thread, even the graphics thread.
 // Created to allow for self shutdown.
-void FifoManager::ExitGpuLoop(Core::System& system)
+void FifoManager::ExitGpuLoop()
 {
-  auto& command_processor = system.GetCommandProcessor();
+  auto& command_processor = m_system.GetCommandProcessor();
   auto& fifo = command_processor.GetFifo();
 
   // This should break the wait loop in CPU thread
   fifo.bFF_GPReadEnable.store(0, std::memory_order_relaxed);
-  FlushGpu(system);
+  FlushGpu();
 
   // Terminate GPU thread loop
   m_emu_running_state.Set();
@@ -211,7 +214,7 @@ void* FifoManager::PopFifoAuxBuffer(size_t size)
 }
 
 // Description: RunGpuLoop() sends data through this function.
-void FifoManager::ReadDataFromFifo(Core::System& system, u32 readPtr)
+void FifoManager::ReadDataFromFifo(u32 read_ptr)
 {
   if (GPFifo::GATHER_PIPE_SIZE >
       static_cast<size_t>(m_video_buffer + FIFO_SIZE - m_video_buffer_write_ptr))
@@ -228,13 +231,13 @@ void FifoManager::ReadDataFromFifo(Core::System& system, u32 readPtr)
     m_video_buffer_read_ptr = m_video_buffer;
   }
   // Copy new video instructions to m_video_buffer for future use in rendering the new picture
-  auto& memory = system.GetMemory();
-  memory.CopyFromEmu(m_video_buffer_write_ptr, readPtr, GPFifo::GATHER_PIPE_SIZE);
+  auto& memory = m_system.GetMemory();
+  memory.CopyFromEmu(m_video_buffer_write_ptr, read_ptr, GPFifo::GATHER_PIPE_SIZE);
   m_video_buffer_write_ptr += GPFifo::GATHER_PIPE_SIZE;
 }
 
 // The deterministic_gpu_thread version.
-void FifoManager::ReadDataFromFifoOnCPU(Core::System& system, u32 readPtr)
+void FifoManager::ReadDataFromFifoOnCPU(u32 read_ptr)
 {
   u8* write_ptr = m_video_buffer_write_ptr;
   if (GPFifo::GATHER_PIPE_SIZE > static_cast<size_t>(m_video_buffer + FIFO_SIZE - write_ptr))
@@ -262,8 +265,8 @@ void FifoManager::ReadDataFromFifoOnCPU(Core::System& system, u32 readPtr)
       return;
     }
   }
-  auto& memory = system.GetMemory();
-  memory.CopyFromEmu(m_video_buffer_write_ptr, readPtr, GPFifo::GATHER_PIPE_SIZE);
+  auto& memory = m_system.GetMemory();
+  memory.CopyFromEmu(m_video_buffer_write_ptr, read_ptr, GPFifo::GATHER_PIPE_SIZE);
   m_video_buffer_pp_read_ptr = OpcodeDecoder::RunFifo<true>(
       DataReader(m_video_buffer_pp_read_ptr, write_ptr + GPFifo::GATHER_PIPE_SIZE), nullptr);
   // This would have to be locked if the GPU thread didn't spin.
@@ -282,13 +285,13 @@ void FifoManager::ResetVideoBuffer()
 
 // Description: Main FIFO update loop
 // Purpose: Keep the Core HW updated about the CPU-GPU distance
-void FifoManager::RunGpuLoop(Core::System& system)
+void FifoManager::RunGpuLoop()
 {
   AsyncRequests::GetInstance()->SetEnable(true);
   AsyncRequests::GetInstance()->SetPassthrough(false);
 
   m_gpu_mainloop.Run(
-      [this, &system] {
+      [this] {
         // Run events from the CPU thread.
         AsyncRequests::GetInstance()->PullEvents();
 
@@ -311,21 +314,22 @@ void FifoManager::RunGpuLoop(Core::System& system)
         }
         else
         {
-          auto& command_processor = system.GetCommandProcessor();
+          auto& command_processor = m_system.GetCommandProcessor();
           auto& fifo = command_processor.GetFifo();
-          command_processor.SetCPStatusFromGPU(system);
+          command_processor.SetCPStatusFromGPU(m_system);
 
           // check if we are able to run this buffer
           while (!command_processor.IsInterruptWaiting() &&
                  fifo.bFF_GPReadEnable.load(std::memory_order_relaxed) &&
-                 fifo.CPReadWriteDistance.load(std::memory_order_relaxed) && !AtBreakpoint(system))
+                 fifo.CPReadWriteDistance.load(std::memory_order_relaxed) &&
+                 !AtBreakpoint(m_system))
           {
             if (m_config_sync_gpu && m_sync_ticks.load() < m_config_sync_gpu_min_distance)
               break;
 
             u32 cyclesExecuted = 0;
             u32 readPtr = fifo.CPReadPointer.load(std::memory_order_relaxed);
-            ReadDataFromFifo(system, readPtr);
+            ReadDataFromFifo(readPtr);
 
             if (readPtr == fifo.CPEnd.load(std::memory_order_relaxed))
               readPtr = fifo.CPBase.load(std::memory_order_relaxed);
@@ -352,7 +356,7 @@ void FifoManager::RunGpuLoop(Core::System& system)
                                            std::memory_order_relaxed);
             }
 
-            command_processor.SetCPStatusFromGPU(system);
+            command_processor.SetCPStatusFromGPU(m_system);
 
             if (m_config_sync_gpu)
             {
@@ -392,9 +396,9 @@ void FifoManager::RunGpuLoop(Core::System& system)
   AsyncRequests::GetInstance()->SetPassthrough(true);
 }
 
-void FifoManager::FlushGpu(Core::System& system)
+void FifoManager::FlushGpu()
 {
-  if (!system.IsDualCoreMode() || m_use_deterministic_gpu_thread)
+  if (!m_system.IsDualCoreMode() || m_use_deterministic_gpu_thread)
     return;
 
   m_gpu_mainloop.Wait();
@@ -414,9 +418,9 @@ bool AtBreakpoint(Core::System& system)
           fifo.CPBreakpoint.load(std::memory_order_relaxed));
 }
 
-void FifoManager::RunGpu(Core::System& system)
+void FifoManager::RunGpu()
 {
-  const bool is_dual_core = system.IsDualCoreMode();
+  const bool is_dual_core = m_system.IsDualCoreMode();
 
   // wake up GPU thread
   if (is_dual_core && !m_use_deterministic_gpu_thread)
@@ -430,25 +434,25 @@ void FifoManager::RunGpu(Core::System& system)
     if (m_syncing_suspended)
     {
       m_syncing_suspended = false;
-      system.GetCoreTiming().ScheduleEvent(GPU_TIME_SLOT_SIZE, m_event_sync_gpu,
-                                           GPU_TIME_SLOT_SIZE);
+      m_system.GetCoreTiming().ScheduleEvent(GPU_TIME_SLOT_SIZE, m_event_sync_gpu,
+                                             GPU_TIME_SLOT_SIZE);
     }
   }
 }
 
-int FifoManager::RunGpuOnCpu(Core::System& system, int ticks)
+int FifoManager::RunGpuOnCpu(int ticks)
 {
-  auto& command_processor = system.GetCommandProcessor();
+  auto& command_processor = m_system.GetCommandProcessor();
   auto& fifo = command_processor.GetFifo();
   bool reset_simd_state = false;
   int available_ticks = int(ticks * m_config_sync_gpu_overclock) + m_sync_ticks.load();
   while (fifo.bFF_GPReadEnable.load(std::memory_order_relaxed) &&
-         fifo.CPReadWriteDistance.load(std::memory_order_relaxed) && !AtBreakpoint(system) &&
+         fifo.CPReadWriteDistance.load(std::memory_order_relaxed) && !AtBreakpoint(m_system) &&
          available_ticks >= 0)
   {
     if (m_use_deterministic_gpu_thread)
     {
-      ReadDataFromFifoOnCPU(system, fifo.CPReadPointer.load(std::memory_order_relaxed));
+      ReadDataFromFifoOnCPU(fifo.CPReadPointer.load(std::memory_order_relaxed));
       m_gpu_mainloop.Wakeup();
     }
     else
@@ -459,7 +463,7 @@ int FifoManager::RunGpuOnCpu(Core::System& system, int ticks)
         Common::FPU::LoadDefaultSIMDState();
         reset_simd_state = true;
       }
-      ReadDataFromFifo(system, fifo.CPReadPointer.load(std::memory_order_relaxed));
+      ReadDataFromFifo(fifo.CPReadPointer.load(std::memory_order_relaxed));
       u32 cycles = 0;
       m_video_buffer_read_ptr = OpcodeDecoder::RunFifo(
           DataReader(m_video_buffer_read_ptr, m_video_buffer_write_ptr), &cycles);
@@ -480,7 +484,7 @@ int FifoManager::RunGpuOnCpu(Core::System& system, int ticks)
     fifo.CPReadWriteDistance.fetch_sub(GPFifo::GATHER_PIPE_SIZE, std::memory_order_relaxed);
   }
 
-  command_processor.SetCPStatusFromGPU(system);
+  command_processor.SetCPStatusFromGPU(m_system);
 
   if (reset_simd_state)
   {
@@ -498,7 +502,7 @@ int FifoManager::RunGpuOnCpu(Core::System& system, int ticks)
   return -available_ticks + GPU_TIME_SLOT_SIZE;
 }
 
-void FifoManager::UpdateWantDeterminism(Core::System& system, bool want)
+void FifoManager::UpdateWantDeterminism(bool want)
 {
   // We are paused (or not running at all yet), so
   // it should be safe to change this.
@@ -516,7 +520,7 @@ void FifoManager::UpdateWantDeterminism(Core::System& system, bool want)
     break;
   }
 
-  gpu_thread = gpu_thread && system.IsDualCoreMode();
+  gpu_thread = gpu_thread && m_system.IsDualCoreMode();
 
   if (m_use_deterministic_gpu_thread != gpu_thread)
   {
@@ -536,7 +540,7 @@ void FifoManager::UpdateWantDeterminism(Core::System& system, bool want)
  * @ticks The gone emulated CPU time.
  * @return A good time to call WaitForGpuThread() next.
  */
-int FifoManager::WaitForGpuThread(Core::System& system, int ticks)
+int FifoManager::WaitForGpuThread(int ticks)
 {
   int old = m_sync_ticks.fetch_add(ticks);
   int now = old + ticks;
@@ -547,7 +551,7 @@ int FifoManager::WaitForGpuThread(Core::System& system, int ticks)
 
   // Wakeup GPU
   if (old < m_config_sync_gpu_min_distance && now >= m_config_sync_gpu_min_distance)
-    RunGpu(system);
+    RunGpu();
 
   // If the GPU is still sleeping, wait for a longer time
   if (now < m_config_sync_gpu_min_distance)
@@ -568,11 +572,11 @@ void FifoManager::SyncGPUCallback(Core::System& system, u64 ticks, s64 cyclesLat
   auto& fifo = system.GetFifo();
   if (!system.IsDualCoreMode() || fifo.m_use_deterministic_gpu_thread)
   {
-    next = fifo.RunGpuOnCpu(system, (int)ticks);
+    next = fifo.RunGpuOnCpu(int(ticks));
   }
   else if (fifo.m_config_sync_gpu)
   {
-    next = fifo.WaitForGpuThread(system, (int)ticks);
+    next = fifo.WaitForGpuThread(int(ticks));
   }
 
   fifo.m_syncing_suspended = next < 0;
@@ -580,20 +584,20 @@ void FifoManager::SyncGPUCallback(Core::System& system, u64 ticks, s64 cyclesLat
     system.GetCoreTiming().ScheduleEvent(next, fifo.m_event_sync_gpu, next);
 }
 
-void FifoManager::SyncGPUForRegisterAccess(Core::System& system)
+void FifoManager::SyncGPUForRegisterAccess()
 {
   SyncGPU(SyncGPUReason::Other);
 
-  if (!system.IsDualCoreMode() || m_use_deterministic_gpu_thread)
-    RunGpuOnCpu(system, GPU_TIME_SLOT_SIZE);
+  if (!m_system.IsDualCoreMode() || m_use_deterministic_gpu_thread)
+    RunGpuOnCpu(GPU_TIME_SLOT_SIZE);
   else if (m_config_sync_gpu)
-    WaitForGpuThread(system, GPU_TIME_SLOT_SIZE);
+    WaitForGpuThread(GPU_TIME_SLOT_SIZE);
 }
 
 // Initialize GPU - CPU thread syncing, this gives us a deterministic way to start the GPU thread.
-void FifoManager::Prepare(Core::System& system)
+void FifoManager::Prepare()
 {
-  m_event_sync_gpu = system.GetCoreTiming().RegisterEvent("SyncGPUCallback", SyncGPUCallback);
+  m_event_sync_gpu = m_system.GetCoreTiming().RegisterEvent("SyncGPUCallback", SyncGPUCallback);
   m_syncing_suspended = true;
 }
 }  // namespace Fifo
diff --git a/Source/Core/VideoCommon/Fifo.h b/Source/Core/VideoCommon/Fifo.h
index 2ee237c782..2fce8fdcb5 100644
--- a/Source/Core/VideoCommon/Fifo.h
+++ b/Source/Core/VideoCommon/Fifo.h
@@ -41,19 +41,19 @@ enum class SyncGPUReason
 class FifoManager final
 {
 public:
-  FifoManager();
+  explicit FifoManager(Core::System& system);
   FifoManager(const FifoManager& other) = delete;
   FifoManager(FifoManager&& other) = delete;
   FifoManager& operator=(const FifoManager& other) = delete;
   FifoManager& operator=(FifoManager&& other) = delete;
   ~FifoManager();
 
-  void Init(Core::System& system);
+  void Init();
   void Shutdown();
-  void Prepare(Core::System& system);  // Must be called from the CPU thread.
+  void Prepare();  // Must be called from the CPU thread.
   void DoState(PointerWrap& f);
-  void PauseAndLock(Core::System& system, bool doLock, bool unpauseOnUnlock);
-  void UpdateWantDeterminism(Core::System& system, bool want);
+  void PauseAndLock(bool do_lock, bool unpause_on_unlock);
+  void UpdateWantDeterminism(bool want);
   bool UseDeterministicGPUThread() const { return m_use_deterministic_gpu_thread; }
   bool UseSyncGPU() const { return m_config_sync_gpu; }
 
@@ -62,25 +62,25 @@ public:
 
   // In single core mode, this runs the GPU for a single slice.
   // In dual core mode, this synchronizes with the GPU thread.
-  void SyncGPUForRegisterAccess(Core::System& system);
+  void SyncGPUForRegisterAccess();
 
   void PushFifoAuxBuffer(const void* ptr, size_t size);
   void* PopFifoAuxBuffer(size_t size);
 
-  void FlushGpu(Core::System& system);
-  void RunGpu(Core::System& system);
+  void FlushGpu();
+  void RunGpu();
   void GpuMaySleep();
-  void RunGpuLoop(Core::System& system);
-  void ExitGpuLoop(Core::System& system);
+  void RunGpuLoop();
+  void ExitGpuLoop();
   void EmulatorState(bool running);
   void ResetVideoBuffer();
 
 private:
   void RefreshConfig();
-  void ReadDataFromFifo(Core::System& system, u32 readPtr);
-  void ReadDataFromFifoOnCPU(Core::System& system, u32 readPtr);
-  int RunGpuOnCpu(Core::System& system, int ticks);
-  int WaitForGpuThread(Core::System& system, int ticks);
+  void ReadDataFromFifo(u32 read_ptr);
+  void ReadDataFromFifoOnCPU(u32 read_ptr);
+  int RunGpuOnCpu(int ticks);
+  int WaitForGpuThread(int ticks);
   static void SyncGPUCallback(Core::System& system, u64 ticks, s64 cyclesLate);
 
   static constexpr u32 FIFO_SIZE = 2 * 1024 * 1024;
@@ -127,6 +127,8 @@ private:
   int m_config_sync_gpu_max_distance = 0;
   int m_config_sync_gpu_min_distance = 0;
   float m_config_sync_gpu_overclock = 0.0f;
+
+  Core::System& m_system;
 };
 
 bool AtBreakpoint(Core::System& system);
diff --git a/Source/Core/VideoCommon/VideoBackendBase.cpp b/Source/Core/VideoCommon/VideoBackendBase.cpp
index 3d00a1e7ec..b34e8d8c02 100644
--- a/Source/Core/VideoCommon/VideoBackendBase.cpp
+++ b/Source/Core/VideoCommon/VideoBackendBase.cpp
@@ -93,7 +93,7 @@ std::string VideoBackendBase::BadShaderFilename(const char* shader_stage, int co
 void VideoBackendBase::Video_ExitLoop()
 {
   auto& system = Core::System::GetInstance();
-  system.GetFifo().ExitGpuLoop(system);
+  system.GetFifo().ExitGpuLoop();
 }
 
 // Run from the CPU thread (from VideoInterface.cpp)
@@ -379,7 +379,7 @@ bool VideoBackendBase::InitializeShared(std::unique_ptr<AbstractGfx> gfx,
   auto& system = Core::System::GetInstance();
   auto& command_processor = system.GetCommandProcessor();
   command_processor.Init(system);
-  system.GetFifo().Init(system);
+  system.GetFifo().Init();
   system.GetPixelEngine().Init(system);
   BPInit();
   VertexLoaderManager::Init();
diff --git a/Source/Core/VideoCommon/VideoConfig.cpp b/Source/Core/VideoCommon/VideoConfig.cpp
index d9cb9ad0c3..daba4be9e1 100644
--- a/Source/Core/VideoCommon/VideoConfig.cpp
+++ b/Source/Core/VideoCommon/VideoConfig.cpp
@@ -67,13 +67,13 @@ void VideoConfig::Refresh()
 
       const bool lock_gpu_thread = Core::IsRunningAndStarted();
       if (lock_gpu_thread)
-        system.GetFifo().PauseAndLock(system, true, false);
+        system.GetFifo().PauseAndLock(true, false);
 
       g_Config.Refresh();
       g_Config.VerifyValidity();
 
       if (lock_gpu_thread)
-        system.GetFifo().PauseAndLock(system, false, true);
+        system.GetFifo().PauseAndLock(false, true);
     });
     s_has_registered_callback = true;
   }