diff --git a/osu.Game/Screens/Play/HUD/KeysPerSecondCounter.cs b/osu.Game/Screens/Play/HUD/KeysPerSecondCounter.cs
index dc9a51dbf3..d32ca1410a 100644
--- a/osu.Game/Screens/Play/HUD/KeysPerSecondCounter.cs
+++ b/osu.Game/Screens/Play/HUD/KeysPerSecondCounter.cs
@@ -1,17 +1,24 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+#nullable disable
+
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Localisation;
+using osu.Framework.Logging;
+using osu.Framework.Timing;
+using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Rulesets.UI;
 using osu.Game.Skinning;
 using osuTK;
 
@@ -19,37 +26,71 @@ namespace osu.Game.Screens.Play.HUD
 {
     public class KeysPerSecondCounter : RollingCounter<int>, ISkinnableDrawable
     {
-        private static Queue<DateTime>? timestamps;
+        private static List<double> timestamps;
+        private static double maxTime = double.NegativeInfinity;
 
-        private static event Action? onNewInput;
-        private readonly TimeSpan refreshSpan = TimeSpan.FromSeconds(1);
+        private static event Action onNewInput;
 
+        private const int invalidation_timeout = 1000;
         private const float alpha_when_invalid = 0.3f;
+
         private readonly Bindable<bool> valid = new Bindable<bool>();
 
+        private static GameplayClock gameplayClock;
+        private static IClock referenceClock;
+
+        private static IClock clock => referenceClock ?? gameplayClock;
+
+        [Resolved(canBeNull: true)]
+        private DrawableRuleset drawableRuleset { get; set; }
+
+        [SettingSource("Smoothing time", "How smooth the counter should change\nThe more it is smooth, the less it's accurate.")]
+        public BindableNumber<double> SmoothingTime { get; } = new BindableNumber<double>(350)
+        {
+            MaxValue = 1000,
+            MinValue = 0
+        };
+
         public static void AddTimestamp()
         {
-            timestamps?.Enqueue(DateTime.Now);
+            Logger.Log($"Input timestamp attempt C: {clock.CurrentTime}ms | GC: {gameplayClock.CurrentTime} | RC: {referenceClock?.CurrentTime ?? -1} | Max: {maxTime})", level: LogLevel.Debug);
+
+            if (clock.CurrentTime >= maxTime)
+            {
+                Logger.Log("Input timestamp added.", level: LogLevel.Debug);
+                timestamps?.Add(clock.CurrentTime);
+                maxTime = timestamps?.Max() ?? clock.CurrentTime;
+            }
+
             onNewInput?.Invoke();
         }
 
-        protected override double RollingDuration => 250;
+        public static void Reset()
+        {
+            timestamps?.Clear();
+            maxTime = int.MinValue;
+        }
+
+        protected override double RollingDuration => SmoothingTime.Value;
 
         public bool UsesFixedAnchor { get; set; }
 
         public KeysPerSecondCounter()
         {
-            timestamps ??= new Queue<DateTime>();
+            timestamps ??= new List<double>();
             Current.Value = 0;
             onNewInput += updateCounter;
+            Scheduler.AddOnce(updateCounter);
         }
 
         [BackgroundDependencyLoader]
-        private void load(OsuColour colours)
+        private void load(OsuColour colours, GameplayClock clock)
         {
+            gameplayClock = clock;
             Colour = colours.BlueLighter;
             valid.BindValueChanged(e =>
                 DrawableCount.FadeTo(e.NewValue ? 1 : alpha_when_invalid, 1000, Easing.OutQuint));
+            referenceClock = drawableRuleset?.FrameStableClock;
         }
 
         protected override void LoadComplete()
@@ -61,21 +102,15 @@ namespace osu.Game.Screens.Play.HUD
 
         protected override void Update()
         {
-            if (timestamps != null)
-            {
-                if (timestamps.TryPeek(out var earliest) && DateTime.Now - earliest >= refreshSpan)
-                    timestamps.Dequeue();
-            }
+            base.Update();
 
             updateCounter();
-
-            base.Update();
         }
 
         private void updateCounter()
         {
-            valid.Value = timestamps != null;
-            Current.Value = timestamps?.Count ?? 0;
+            valid.Value = timestamps != null && MathHelper.ApproximatelyEquivalent(gameplayClock.CurrentTime, referenceClock.CurrentTime, 500);
+            Current.Value = timestamps?.Count(timestamp => clock.CurrentTime - timestamp is >= 0 and <= invalidation_timeout) ?? 0;
         }
 
         protected override IHasText CreateText() => new TextComponent
diff --git a/osu.Game/Screens/Play/KeyCounterDisplay.cs b/osu.Game/Screens/Play/KeyCounterDisplay.cs
index b6094726c0..aaf2e997f2 100644
--- a/osu.Game/Screens/Play/KeyCounterDisplay.cs
+++ b/osu.Game/Screens/Play/KeyCounterDisplay.cs
@@ -11,6 +11,7 @@ using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Events;
 using osu.Game.Configuration;
+using osu.Game.Screens.Play.HUD;
 using osuTK;
 using osuTK.Graphics;
 
@@ -65,6 +66,7 @@ namespace osu.Game.Screens.Play
         [BackgroundDependencyLoader]
         private void load(OsuConfigManager config)
         {
+            KeysPerSecondCounter.Reset();
             config.BindWith(OsuSetting.KeyOverlay, configVisibility);
         }
 
diff --git a/osu.Game/Screens/Play/Player.cs b/osu.Game/Screens/Play/Player.cs
index 9a058e45c5..fb2f556611 100644
--- a/osu.Game/Screens/Play/Player.cs
+++ b/osu.Game/Screens/Play/Player.cs
@@ -34,6 +34,7 @@ using osu.Game.Rulesets.Scoring;
 using osu.Game.Rulesets.UI;
 using osu.Game.Scoring;
 using osu.Game.Scoring.Legacy;
+using osu.Game.Screens.Play.HUD;
 using osu.Game.Screens.Ranking;
 using osu.Game.Skinning;
 using osu.Game.Users;
@@ -1044,6 +1045,9 @@ namespace osu.Game.Screens.Play
             musicController.ResetTrackAdjustments();
 
             fadeOut();
+
+            KeysPerSecondCounter.Reset();
+
             return base.OnExiting(e);
         }