diff --git a/osu.Game/Graphics/UserInterface/FPSCounter.cs b/osu.Game/Graphics/UserInterface/FPSCounter.cs
index 07eb9fa3ca..6fa53b32d8 100644
--- a/osu.Game/Graphics/UserInterface/FPSCounter.cs
+++ b/osu.Game/Graphics/UserInterface/FPSCounter.cs
@@ -12,6 +12,7 @@ using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
 using osu.Framework.Platform;
 using osu.Framework.Threading;
+using osu.Framework.Timing;
 using osu.Framework.Utils;
 using osu.Game.Configuration;
 using osu.Game.Graphics.Sprites;
@@ -30,6 +31,10 @@ namespace osu.Game.Graphics.UserInterface
 
         private Container counters = null!;
 
+        private const double min_time_between_updates = 10;
+
+        private const double spike_time_ms = 20;
+
         private const float idle_background_alpha = 0.4f;
 
         private readonly BindableBool showFpsDisplay = new BindableBool(true);
@@ -37,6 +42,18 @@ namespace osu.Game.Graphics.UserInterface
         private double displayedFpsCount;
         private double displayedFrameTime;
 
+        private bool isDisplayed;
+
+        private ScheduledDelegate? fadeOutDelegate;
+
+        private double aimDrawFPS;
+        private double aimUpdateFPS;
+
+        private double lastUpdate;
+        private ThrottledFrameClock drawClock = null!;
+        private ThrottledFrameClock updateClock = null!;
+        private ThrottledFrameClock inputClock = null!;
+
         [Resolved]
         private OsuColour colours { get; set; } = null!;
 
@@ -46,7 +63,7 @@ namespace osu.Game.Graphics.UserInterface
         }
 
         [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
+        private void load(OsuConfigManager config, GameHost gameHost)
         {
             InternalChildren = new Drawable[]
             {
@@ -104,6 +121,10 @@ namespace osu.Game.Graphics.UserInterface
             };
 
             config.BindWith(OsuSetting.ShowFpsDisplay, showFpsDisplay);
+
+            drawClock = gameHost.DrawThread.Clock;
+            updateClock = gameHost.UpdateThread.Clock;
+            inputClock = gameHost.InputThread.Clock;
         }
 
         protected override void LoadComplete()
@@ -140,13 +161,6 @@ namespace osu.Game.Graphics.UserInterface
             base.OnHoverLost(e);
         }
 
-        private bool isDisplayed;
-
-        private ScheduledDelegate? fadeOutDelegate;
-
-        private double aimDrawFPS;
-        private double aimUpdateFPS;
-
         private void displayTemporarily()
         {
             if (!isDisplayed)
@@ -168,9 +182,6 @@ namespace osu.Game.Graphics.UserInterface
             }
         }
 
-        [Resolved]
-        private GameHost gameHost { get; set; } = null!;
-
         protected override void Update()
         {
             base.Update();
@@ -181,29 +192,27 @@ namespace osu.Game.Graphics.UserInterface
             // frame limiter (we want to show the FPS as it's changing, even if it isn't an outlier).
             bool aimRatesChanged = updateAimFPS();
 
-            // TODO: this is wrong (elapsed clock time, not actual run time).
-            double newUpdateFrameTime = gameHost.UpdateThread.Clock.ElapsedFrameTime;
-            double newDrawFrameTime = gameHost.DrawThread.Clock.ElapsedFrameTime;
-            double newDrawFps = gameHost.DrawThread.Clock.FramesPerSecond;
-
-            const double spike_time_ms = 20;
-
-            bool hasUpdateSpike = displayedFrameTime < spike_time_ms && newUpdateFrameTime > spike_time_ms;
+            bool hasUpdateSpike = displayedFrameTime < spike_time_ms && updateClock.ElapsedFrameTime > spike_time_ms;
             // use elapsed frame time rather then FramesPerSecond to better catch stutter frames.
-            bool hasDrawSpike = displayedFpsCount > (1000 / spike_time_ms) && newDrawFrameTime > spike_time_ms;
+            bool hasDrawSpike = displayedFpsCount > (1000 / spike_time_ms) && drawClock.ElapsedFrameTime > spike_time_ms;
 
             // note that we use an elapsed time here of 1 intentionally.
             // this weights all updates equally. if we passed in the elapsed time, longer frames would be weighted incorrectly lower.
-            displayedFrameTime = Interpolation.DampContinuously(displayedFrameTime, newUpdateFrameTime, hasUpdateSpike ? 0 : 100, 1);
+            displayedFrameTime = Interpolation.DampContinuously(displayedFrameTime, updateClock.ElapsedFrameTime, hasUpdateSpike ? 0 : 100, 1);
 
             if (hasDrawSpike)
                 // show spike time using raw elapsed value, to account for `FramesPerSecond` being so averaged spike frames don't show.
-                displayedFpsCount = 1000 / newDrawFrameTime;
+                displayedFpsCount = 1000 / drawClock.ElapsedFrameTime;
             else
-                displayedFpsCount = Interpolation.DampContinuously(displayedFpsCount, newDrawFps, 100, Time.Elapsed);
+                displayedFpsCount = Interpolation.DampContinuously(displayedFpsCount, drawClock.FramesPerSecond, 100, Time.Elapsed);
 
-            updateFpsDisplay();
-            updateFrameTimeDisplay();
+            if (Time.Current - lastUpdate > min_time_between_updates)
+            {
+                updateFpsDisplay();
+                updateFrameTimeDisplay();
+
+                lastUpdate = Time.Current;
+            }
 
             bool hasSignificantChanges = aimRatesChanged
                                          || hasDrawSpike
@@ -232,10 +241,10 @@ namespace osu.Game.Graphics.UserInterface
 
         private bool updateAimFPS()
         {
-            if (gameHost.UpdateThread.Clock.Throttling)
+            if (updateClock.Throttling)
             {
-                double newAimDrawFPS = gameHost.DrawThread.Clock.MaximumUpdateHz;
-                double newAimUpdateFPS = gameHost.UpdateThread.Clock.MaximumUpdateHz;
+                double newAimDrawFPS = drawClock.MaximumUpdateHz;
+                double newAimUpdateFPS = updateClock.MaximumUpdateHz;
 
                 if (aimDrawFPS != newAimDrawFPS || aimUpdateFPS != newAimUpdateFPS)
                 {
@@ -246,7 +255,7 @@ namespace osu.Game.Graphics.UserInterface
             }
             else
             {
-                double newAimFPS = gameHost.InputThread.Clock.MaximumUpdateHz;
+                double newAimFPS = inputClock.MaximumUpdateHz;
 
                 if (aimDrawFPS != newAimFPS || aimUpdateFPS != newAimFPS)
                 {