diff --git a/osu.Game.Rulesets.Mania.Tests/ManiaDifficultyCalculatorTest.cs b/osu.Game.Rulesets.Mania.Tests/ManiaDifficultyCalculatorTest.cs
index 9e4db1f1c9..4ae6cb9c7c 100644
--- a/osu.Game.Rulesets.Mania.Tests/ManiaDifficultyCalculatorTest.cs
+++ b/osu.Game.Rulesets.Mania.Tests/ManiaDifficultyCalculatorTest.cs
@@ -16,11 +16,11 @@ namespace osu.Game.Rulesets.Mania.Tests
     {
         protected override string ResourceAssembly => "osu.Game.Rulesets.Mania";
 
-        [TestCase(2.3449735700206298d, 242, "diffcalc-test")]
+        [TestCase(2.3493769750220914d, 242, "diffcalc-test")]
         public void Test(double expectedStarRating, int expectedMaxCombo, string name)
             => base.Test(expectedStarRating, expectedMaxCombo, name);
 
-        [TestCase(2.7879104989252959d, 242, "diffcalc-test")]
+        [TestCase(2.797245912537965d, 242, "diffcalc-test")]
         public void TestClockRateAdjusted(double expectedStarRating, int expectedMaxCombo, string name)
             => Test(expectedStarRating, expectedMaxCombo, name, new ManiaModDoubleTime());
 
diff --git a/osu.Game.Rulesets.Mania/Difficulty/Skills/Strain.cs b/osu.Game.Rulesets.Mania/Difficulty/Skills/Strain.cs
index c2e532430c..2c7c84de97 100644
--- a/osu.Game.Rulesets.Mania/Difficulty/Skills/Strain.cs
+++ b/osu.Game.Rulesets.Mania/Difficulty/Skills/Strain.cs
@@ -21,7 +21,8 @@ namespace osu.Game.Rulesets.Mania.Difficulty.Skills
         protected override double SkillMultiplier => 1;
         protected override double StrainDecayBase => 1;
 
-        private readonly double[] holdEndTimes;
+        private readonly double[] startTimes;
+        private readonly double[] endTimes;
         private readonly double[] individualStrains;
 
         private double individualStrain;
@@ -30,7 +31,8 @@ namespace osu.Game.Rulesets.Mania.Difficulty.Skills
         public Strain(Mod[] mods, int totalColumns)
             : base(mods)
         {
-            holdEndTimes = new double[totalColumns];
+            startTimes = new double[totalColumns];
+            endTimes = new double[totalColumns];
             individualStrains = new double[totalColumns];
             overallStrain = 1;
         }
@@ -38,32 +40,27 @@ namespace osu.Game.Rulesets.Mania.Difficulty.Skills
         protected override double StrainValueOf(DifficultyHitObject current)
         {
             var maniaCurrent = (ManiaDifficultyHitObject)current;
+            double startTime = maniaCurrent.StartTime;
             double endTime = maniaCurrent.EndTime;
             int column = maniaCurrent.BaseObject.Column;
-            double closestEndTime = Math.Abs(endTime - maniaCurrent.LastObject.StartTime); // Lowest value we can assume with the current information
-
-            double holdFactor = 1.0; // Factor to all additional strains in case something else is held
-            double holdAddition = 0; // Addition to the current note in case it's a hold and has to be released awkwardly
             bool isOverlapping = false;
 
-            // Fill up the holdEndTimes array
-            for (int i = 0; i < holdEndTimes.Length; ++i)
+            double closestEndTime = Math.Abs(endTime - startTime); // Lowest value we can assume with the current information
+            double holdFactor = 1.0; // Factor to all additional strains in case something else is held
+            double holdAddition = 0; // Addition to the current note in case it's a hold and has to be released awkwardly
+
+            for (int i = 0; i < endTimes.Length; ++i)
             {
                 // The current note is overlapped if a previous note or end is overlapping the current note body
-                isOverlapping |= Precision.DefinitelyBigger(holdEndTimes[i], maniaCurrent.StartTime, 1) && Precision.DefinitelyBigger(endTime, holdEndTimes[i], 1);
+                isOverlapping |= Precision.DefinitelyBigger(endTimes[i], startTime, 1) && Precision.DefinitelyBigger(endTime, endTimes[i], 1);
 
                 // We give a slight bonus to everything if something is held meanwhile
-                if (Precision.DefinitelyBigger(holdEndTimes[i], endTime, 1))
+                if (Precision.DefinitelyBigger(endTimes[i], endTime, 1))
                     holdFactor = 1.25;
 
-                closestEndTime = Math.Min(closestEndTime, Math.Abs(endTime - holdEndTimes[i]));
-
-                // Decay individual strains
-                individualStrains[i] = applyDecay(individualStrains[i], current.DeltaTime, individual_decay_base);
+                closestEndTime = Math.Min(closestEndTime, Math.Abs(endTime - endTimes[i]));
             }
 
-            holdEndTimes[column] = endTime;
-
             // The hold addition is given if there was an overlap, however it is only valid if there are no other note with a similar ending.
             // Releasing multiple notes is just as easy as releasing 1. Nerfs the hold addition by half if the closest release is release_threshold away.
             // holdAddition
@@ -77,12 +74,22 @@ namespace osu.Game.Rulesets.Mania.Difficulty.Skills
             if (isOverlapping)
                 holdAddition = 1 / (1 + Math.Exp(0.5 * (release_threshold - closestEndTime)));
 
-            // Increase individual strain in own column
+            // Decay and increase individualStrains in own column
+            individualStrains[column] = applyDecay(individualStrains[column], startTime - startTimes[column], individual_decay_base);
             individualStrains[column] += 2.0 * holdFactor;
-            individualStrain = individualStrains[column];
 
-            overallStrain = applyDecay(overallStrain, current.DeltaTime, overall_decay_base) + (1 + holdAddition) * holdFactor;
+            // For notes at the same time (in a chord), the individualStrain should be the hardest individualStrain out of those columns
+            individualStrain = maniaCurrent.DeltaTime <= 1 ? Math.Max(individualStrain, individualStrains[column]) : individualStrains[column];
 
+            // Decay and increase overallStrain
+            overallStrain = applyDecay(overallStrain, current.DeltaTime, overall_decay_base);
+            overallStrain += (1 + holdAddition) * holdFactor;
+
+            // Update startTimes and endTimes arrays
+            startTimes[column] = startTime;
+            endTimes[column] = endTime;
+
+            // By subtracting CurrentStrain, this skill effectively only considers the maximum strain of any one hitobject within each strain section.
             return individualStrain + overallStrain - CurrentStrain;
         }