diff --git a/osu.Game/Rulesets/UI/DrawableRuleset.cs b/osu.Game/Rulesets/UI/DrawableRuleset.cs
index e0a1533c4b..57f5f54d8f 100644
--- a/osu.Game/Rulesets/UI/DrawableRuleset.cs
+++ b/osu.Game/Rulesets/UI/DrawableRuleset.cs
@@ -30,6 +30,8 @@ using osu.Game.Rulesets.Objects.Drawables;
 using osu.Game.Rulesets.Scoring;
 using osu.Game.Scoring;
 using osu.Game.Screens.Play;
+using osu.Game.Screens.Play.HUD;
+using osu.Game.Screens.Play.HUD.ClicksPerSecond;
 using osuTK;
 
 namespace osu.Game.Rulesets.UI
@@ -38,7 +40,7 @@ namespace osu.Game.Rulesets.UI
     /// Displays an interactive ruleset gameplay instance.
     /// </summary>
     /// <typeparam name="TObject">The type of HitObject contained by this DrawableRuleset.</typeparam>
-    public abstract partial class DrawableRuleset<TObject> : DrawableRuleset, IProvideCursor, IKeybindingEventsEmitter
+    public abstract partial class DrawableRuleset<TObject> : DrawableRuleset, IProvideCursor, ICanAttachHUDPieces
         where TObject : HitObject
     {
         public override event Action<JudgementResult> NewResult;
@@ -327,8 +329,11 @@ namespace osu.Game.Rulesets.UI
         /// <returns>The representing <see cref="DrawableHitObject{TObject}"/>.</returns>
         public abstract DrawableHitObject<TObject> CreateDrawableRepresentation(TObject h);
 
-        public void Attach(IKeybindingListener skinComponent) =>
-            (KeyBindingInputManager as IKeybindingEventsEmitter)?.Attach(skinComponent);
+        public void Attach(KeyCounterController keyCounter) =>
+            (KeyBindingInputManager as ICanAttachHUDPieces)?.Attach(keyCounter);
+
+        public void Attach(ClicksPerSecondCalculator calculator) =>
+            (KeyBindingInputManager as ICanAttachHUDPieces)?.Attach(calculator);
 
         /// <summary>
         /// Creates a key conversion input manager. An exception will be thrown if a valid <see cref="RulesetInputManager{T}"/> is not returned.
diff --git a/osu.Game/Rulesets/UI/IKeybindingListener.cs b/osu.Game/Rulesets/UI/IKeybindingListener.cs
deleted file mode 100644
index f38ce8643e..0000000000
--- a/osu.Game/Rulesets/UI/IKeybindingListener.cs
+++ /dev/null
@@ -1,50 +0,0 @@
-// 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.Collections.Generic;
-using osu.Framework.Graphics.Containers;
-using osu.Framework.Input.Bindings;
-using osu.Framework.Input.Events;
-
-namespace osu.Game.Rulesets.UI
-{
-    /// <summary>
-    /// Listens to <see cref="IKeyBinding"/> events emitted by an <see cref="IKeybindingEventsEmitter"/>.
-    /// Alternative to <see cref="IKeyBindingHandler{T}"/> for classes that need to not depend on type parameters.
-    /// </summary>
-    public interface IKeybindingListener
-    {
-        /// <summary>
-        /// This class or a member of this class can already handle keybindings.
-        /// Signals to the <see cref="IKeybindingEventsEmitter"/> that <see cref="OnPressed{T}"/> and <see cref="OnReleased{T}"/>
-        /// don't necessarily need to be called.
-        /// </summary>
-        /// <remarks>
-        /// This is usually true for <see cref="CompositeDrawable"/>s and <see cref="CompositeComponent"/>s that need to
-        /// pass <see cref="IKeyBinding"/>s events to children that can already handle them.
-        /// </remarks>
-        public bool CanHandleKeybindings { get; }
-
-        /// <summary>
-        /// Prepares this class to receive events.
-        /// </summary>
-        /// <param name="actions">The list of possible actions that can occur.</param>
-        /// <typeparam name="T">The type actions, commonly enums.</typeparam>
-        public void Setup<T>(IEnumerable<T> actions) where T : struct;
-
-        /// <summary>
-        /// Called when an action is pressed.
-        /// </summary>
-        /// <param name="action">The event containing information about the pressed action.</param>
-        /// <typeparam name="T">The type of binding, commonly enums.</typeparam>
-        public void OnPressed<T>(KeyBindingPressEvent<T> action) where T : struct;
-
-        /// <summary>
-        /// Called when an action is released.
-        /// </summary>
-        /// <param name="action">The event containing information about the released action.</param>
-        /// <typeparam name="T">The type of binding, commonly enums.</typeparam>
-        public void OnReleased<T>(KeyBindingReleaseEvent<T> action) where T : struct;
-    }
-}
diff --git a/osu.Game/Rulesets/UI/RulesetInputManager.cs b/osu.Game/Rulesets/UI/RulesetInputManager.cs
index 44c1f00cf7..2c403139b6 100644
--- a/osu.Game/Rulesets/UI/RulesetInputManager.cs
+++ b/osu.Game/Rulesets/UI/RulesetInputManager.cs
@@ -19,11 +19,13 @@ using osu.Game.Input;
 using osu.Game.Input.Bindings;
 using osu.Game.Input.Handlers;
 using osu.Game.Rulesets.Scoring;
+using osu.Game.Screens.Play.HUD;
+using osu.Game.Screens.Play.HUD.ClicksPerSecond;
 using static osu.Game.Input.Handlers.ReplayInputHandler;
 
 namespace osu.Game.Rulesets.UI
 {
-    public abstract partial class RulesetInputManager<T> : PassThroughInputManager, IKeybindingEventsEmitter, IHasReplayHandler, IHasRecordingHandler
+    public abstract partial class RulesetInputManager<T> : PassThroughInputManager, ICanAttachHUDPieces, IHasReplayHandler, IHasRecordingHandler
         where T : struct
     {
         protected override bool AllowRightClickFromLongTouch => false;
@@ -64,7 +66,6 @@ namespace osu.Game.Rulesets.UI
             InternalChild = KeyBindingContainer =
                 CreateKeyBindingContainer(ruleset, variant, unique)
                     .WithChild(content = new Container { RelativeSizeAxes = Axes.Both });
-            KeyBindingContainer.Add(actionListener = new ActionListener());
         }
 
         [BackgroundDependencyLoader(true)]
@@ -157,49 +158,47 @@ namespace osu.Game.Rulesets.UI
 
         #endregion
 
-        #region Component attachement
+        #region Key Counter Attachment
 
-        private readonly ActionListener actionListener;
-
-        public void Attach(IKeybindingListener skinComponent)
+        public void Attach(KeyCounterController keyCounter)
         {
-            skinComponent.Setup(KeyBindingContainer.DefaultKeyBindings
+            KeyBindingContainer.Add(keyCounter);
+
+            keyCounter.AddRange(KeyBindingContainer.DefaultKeyBindings
                                                    .Select(b => b.GetAction<T>())
                                                    .Distinct()
-                                                   .OrderBy(a => a));
+                                                   .OrderBy(action => action)
+                                                   .Select(action => new KeyCounterActionTrigger<T>(action)));
+        }
 
-            if (skinComponent.CanHandleKeybindings && skinComponent is Drawable component)
-            {
-                try
-                {
-                    KeyBindingContainer.Add(component);
-                    return;
-                }
-                catch (Exception)
-                {
-                    return;
-                }
-            }
+        #endregion
 
-            actionListener.OnPressedEvent += skinComponent.OnPressed;
-            actionListener.OnReleasedEvent += skinComponent.OnReleased;
+        #region Keys per second Counter Attachment
+
+        public void Attach(ClicksPerSecondCalculator calculator)
+        {
+            var listener = new ActionListener(calculator);
+
+            KeyBindingContainer.Add(listener);
         }
 
         private partial class ActionListener : Component, IKeyBindingHandler<T>
         {
-            public event Action<KeyBindingPressEvent<T>> OnPressedEvent;
+            private readonly ClicksPerSecondCalculator calculator;
 
-            public event Action<KeyBindingReleaseEvent<T>> OnReleasedEvent;
+            public ActionListener(ClicksPerSecondCalculator calculator)
+            {
+                this.calculator = calculator;
+            }
 
             public bool OnPressed(KeyBindingPressEvent<T> e)
             {
-                OnPressedEvent?.Invoke(e);
+                calculator.AddInputTimestamp();
                 return false;
             }
 
             public void OnReleased(KeyBindingReleaseEvent<T> e)
             {
-                OnReleasedEvent?.Invoke(e);
             }
         }
 
@@ -240,11 +239,17 @@ namespace osu.Game.Rulesets.UI
     }
 
     /// <summary>
-    /// Sends <see cref="IKeyBinding"/> events to a <see cref="IKeybindingListener"/>
+    /// Supports attaching various HUD pieces.
+    /// Keys will be populated automatically and a receptor will be injected inside.
     /// </summary>
-    public interface IKeybindingEventsEmitter
+    public interface ICanAttachHUDPieces
+    {
+        void Attach(KeyCounterController keyCounter);
+        void Attach(ClicksPerSecondCalculator calculator);
+    }
+
+    public interface IAttachableSkinComponent
     {
-        void Attach(IKeybindingListener component);
     }
 
     public class RulesetInputManagerInputState<T> : InputState
diff --git a/osu.Game/Screens/Play/HUD/ClicksPerSecond/ClicksPerSecondCalculator.cs b/osu.Game/Screens/Play/HUD/ClicksPerSecond/ClicksPerSecondCalculator.cs
index e0e93cb66e..3e55e11f1c 100644
--- a/osu.Game/Screens/Play/HUD/ClicksPerSecond/ClicksPerSecondCalculator.cs
+++ b/osu.Game/Screens/Play/HUD/ClicksPerSecond/ClicksPerSecondCalculator.cs
@@ -4,12 +4,11 @@
 using System.Collections.Generic;
 using osu.Framework.Allocation;
 using osu.Framework.Graphics;
-using osu.Framework.Input.Events;
 using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Screens.Play.HUD.ClicksPerSecond
 {
-    public partial class ClicksPerSecondCalculator : Component, IKeybindingListener
+    public partial class ClicksPerSecondCalculator : Component, IAttachableSkinComponent
     {
         private readonly List<double> timestamps = new List<double>();
 
@@ -54,21 +53,5 @@ namespace osu.Game.Screens.Play.HUD.ClicksPerSecond
 
             Value = count;
         }
-
-        #region IKeybindingListener
-
-        bool IKeybindingListener.CanHandleKeybindings => false;
-
-        void IKeybindingListener.Setup<T>(IEnumerable<T> actions)
-        {
-        }
-
-        void IKeybindingListener.OnPressed<T>(KeyBindingPressEvent<T> action) => AddInputTimestamp();
-
-        void IKeybindingListener.OnReleased<T>(KeyBindingReleaseEvent<T> action)
-        {
-        }
-
-        #endregion
     }
 }
diff --git a/osu.Game/Screens/Play/HUD/KeyCounterController.cs b/osu.Game/Screens/Play/HUD/KeyCounterController.cs
index 2e678e55fc..0fa02afbb4 100644
--- a/osu.Game/Screens/Play/HUD/KeyCounterController.cs
+++ b/osu.Game/Screens/Play/HUD/KeyCounterController.cs
@@ -3,16 +3,14 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics.Containers;
-using osu.Framework.Input.Events;
 using osu.Game.Rulesets.UI;
 
 namespace osu.Game.Screens.Play.HUD
 {
-    public partial class KeyCounterController : CompositeComponent, IKeybindingListener
+    public partial class KeyCounterController : CompositeComponent, IAttachableSkinComponent
     {
         public readonly Bindable<bool> IsCounting = new BindableBool(true);
 
@@ -38,22 +36,5 @@ namespace osu.Game.Screens.Play.HUD
         public override bool HandleNonPositionalInput => true;
 
         public override bool HandlePositionalInput => true;
-
-        #region IKeybindingListener
-
-        bool IKeybindingListener.CanHandleKeybindings => true;
-
-        void IKeybindingListener.Setup<T>(IEnumerable<T> actions)
-            => AddRange(actions.Select(a => new KeyCounterActionTrigger<T>(a)));
-
-        void IKeybindingListener.OnPressed<T>(KeyBindingPressEvent<T> action)
-        {
-        }
-
-        void IKeybindingListener.OnReleased<T>(KeyBindingReleaseEvent<T> action)
-        {
-        }
-
-        #endregion
     }
 }
diff --git a/osu.Game/Screens/Play/HUDOverlay.cs b/osu.Game/Screens/Play/HUDOverlay.cs
index b74b5d835a..21636ac04c 100644
--- a/osu.Game/Screens/Play/HUDOverlay.cs
+++ b/osu.Game/Screens/Play/HUDOverlay.cs
@@ -10,7 +10,6 @@ using JetBrains.Annotations;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions.EnumExtensions;
-using osu.Framework.Extensions.IEnumerableExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input.Bindings;
@@ -103,8 +102,6 @@ namespace osu.Game.Screens.Play
 
         private readonly List<Drawable> hideTargets;
 
-        private readonly IEnumerable<IKeybindingListener> actionInjectionCandidates;
-
         public HUDOverlay(DrawableRuleset drawableRuleset, IReadOnlyList<Mod> mods, bool alwaysShowLeaderboard = true)
         {
             Drawable rulesetComponents;
@@ -166,8 +163,6 @@ namespace osu.Game.Screens.Play
 
             hideTargets = new List<Drawable> { mainComponents, rulesetComponents, topRightElements };
 
-            actionInjectionCandidates = new IKeybindingListener[] { clicksPerSecondCalculator, KeyCounter };
-
             if (!alwaysShowLeaderboard)
                 hideTargets.Add(LeaderboardFlow);
         }
@@ -324,8 +319,11 @@ namespace osu.Game.Screens.Play
 
         protected virtual void BindDrawableRuleset(DrawableRuleset drawableRuleset)
         {
-            if (drawableRuleset is IKeybindingEventsEmitter attachTarget)
-                actionInjectionCandidates.ForEach(attachTarget.Attach);
+            if (drawableRuleset is ICanAttachHUDPieces attachTarget)
+            {
+                attachTarget.Attach(KeyCounter);
+                attachTarget.Attach(clicksPerSecondCalculator);
+            }
 
             replayLoaded.BindTo(drawableRuleset.HasReplayLoaded);
         }