diff --git a/PerformanceCalculator/Difficulty/DifficultyCommand.cs b/PerformanceCalculator/Difficulty/DifficultyCommand.cs
index daf8963..0c8c487 100644
--- a/PerformanceCalculator/Difficulty/DifficultyCommand.cs
+++ b/PerformanceCalculator/Difficulty/DifficultyCommand.cs
@@ -126,7 +126,7 @@ namespace PerformanceCalculator.Difficulty
         {
             // Get the ruleset
             var ruleset = LegacyHelper.GetRulesetFromLegacyID(Ruleset ?? beatmap.BeatmapInfo.Ruleset.OnlineID);
-            var mods = LegacyHelper.TrimNonDifficultyAdjustmentMods(ruleset, getMods(ruleset).ToArray());
+            var mods = LegacyHelper.ConvertToLegacyDifficultyAdjustmentMods(ruleset, getMods(ruleset).ToArray());
             var attributes = ruleset.CreateDifficultyCalculator(beatmap).Calculate(mods);
 
             return new Result
diff --git a/PerformanceCalculator/Leaderboard/LeaderboardCommand.cs b/PerformanceCalculator/Leaderboard/LeaderboardCommand.cs
index 3618825..6146c04 100644
--- a/PerformanceCalculator/Leaderboard/LeaderboardCommand.cs
+++ b/PerformanceCalculator/Leaderboard/LeaderboardCommand.cs
@@ -81,7 +81,7 @@ namespace PerformanceCalculator.Leaderboard
                     var score = new ProcessorScoreDecoder(working).Parse(scoreInfo);
 
                     var difficultyCalculator = ruleset.CreateDifficultyCalculator(working);
-                    var difficultyAttributes = difficultyCalculator.Calculate(LegacyHelper.TrimNonDifficultyAdjustmentMods(ruleset, scoreInfo.Mods).ToArray());
+                    var difficultyAttributes = difficultyCalculator.Calculate(LegacyHelper.ConvertToLegacyDifficultyAdjustmentMods(ruleset, scoreInfo.Mods).ToArray());
                     var performanceCalculator = ruleset.CreatePerformanceCalculator(difficultyAttributes, score.ScoreInfo);
 
                     plays.Add((performanceCalculator?.Calculate().Total ?? 0, play.pp));
diff --git a/PerformanceCalculator/LegacyHelper.cs b/PerformanceCalculator/LegacyHelper.cs
index bd56c62..4399e28 100644
--- a/PerformanceCalculator/LegacyHelper.cs
+++ b/PerformanceCalculator/LegacyHelper.cs
@@ -2,6 +2,7 @@
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using osu.Framework.Audio.Track;
@@ -63,10 +64,10 @@ namespace PerformanceCalculator
         }
 
         /// <summary>
-        /// Trims all mods from a given <see cref="Mod"/> array which do not adjust difficulty.
+        /// Transforms a given <see cref="Mod"/> combination into one which is applicable to legacy scores.
         /// This is used to match osu!stable/osu!web calculations for the time being, until such a point that these mods do get considered.
         /// </summary>
-        public static Mod[] TrimNonDifficultyAdjustmentMods(Ruleset ruleset, Mod[] mods)
+        public static Mod[] ConvertToLegacyDifficultyAdjustmentMods(Ruleset ruleset, Mod[] mods)
         {
             var beatmap = new EmptyWorkingBeatmap
             {
@@ -77,17 +78,27 @@ namespace PerformanceCalculator
                 }
             };
 
-            var difficultyAdjustmentMods = ModUtils.FlattenMods(
-                                                       ruleset.CreateDifficultyCalculator(beatmap).CreateDifficultyAdjustmentModCombinations())
-                                                   .Select(m => m.GetType())
-                                                   .Distinct()
-                                                   .ToHashSet();
+            var allMods = ruleset.CreateAllMods().ToArray();
 
-            // Special case for DT/NC.
+            var allowedMods = ModUtils.FlattenMods(
+                                          ruleset.CreateDifficultyCalculator(beatmap).CreateDifficultyAdjustmentModCombinations())
+                                      .Select(m => m.GetType())
+                                      .Distinct()
+                                      .ToHashSet();
+
+            // Special case to allow either DT or NC.
             if (mods.Any(m => m is ModDoubleTime))
-                difficultyAdjustmentMods.Add(ruleset.CreateAllMods().Single(m => m is ModNightcore).GetType());
+                allowedMods.Add(allMods.Single(m => m is ModNightcore).GetType());
 
-            return mods.Where(m => difficultyAdjustmentMods.Contains(m.GetType())).ToArray();
+            var result = new List<Mod>();
+
+            var classicMod = allMods.SingleOrDefault(m => m is ModClassic);
+            if (classicMod != null)
+                result.Add(classicMod);
+
+            result.AddRange(mods.Where(m => allowedMods.Contains(m.GetType())));
+
+            return result.ToArray();
         }
 
         private class EmptyWorkingBeatmap : WorkingBeatmap
diff --git a/PerformanceCalculator/Performance/PerformanceCommand.cs b/PerformanceCalculator/Performance/PerformanceCommand.cs
index eae7447..828869d 100644
--- a/PerformanceCalculator/Performance/PerformanceCommand.cs
+++ b/PerformanceCalculator/Performance/PerformanceCommand.cs
@@ -40,7 +40,7 @@ namespace PerformanceCalculator.Performance
 
                 var ruleset = score.ScoreInfo.Ruleset.CreateInstance();
                 var difficultyCalculator = ruleset.CreateDifficultyCalculator(workingBeatmap);
-                var difficultyAttributes = difficultyCalculator.Calculate(LegacyHelper.TrimNonDifficultyAdjustmentMods(ruleset, score.ScoreInfo.Mods).ToArray());
+                var difficultyAttributes = difficultyCalculator.Calculate(LegacyHelper.ConvertToLegacyDifficultyAdjustmentMods(ruleset, score.ScoreInfo.Mods).ToArray());
                 var performanceCalculator = score.ScoreInfo.Ruleset.CreateInstance().CreatePerformanceCalculator(difficultyAttributes, score.ScoreInfo);
 
                 var ppAttributes = performanceCalculator?.Calculate();
diff --git a/PerformanceCalculator/Profile/ProfileCommand.cs b/PerformanceCalculator/Profile/ProfileCommand.cs
index d7f5124..fc6d61e 100644
--- a/PerformanceCalculator/Profile/ProfileCommand.cs
+++ b/PerformanceCalculator/Profile/ProfileCommand.cs
@@ -73,7 +73,7 @@ namespace PerformanceCalculator.Profile
                 var score = new ProcessorScoreDecoder(working).Parse(scoreInfo);
 
                 var difficultyCalculator = ruleset.CreateDifficultyCalculator(working);
-                var difficultyAttributes = difficultyCalculator.Calculate(LegacyHelper.TrimNonDifficultyAdjustmentMods(ruleset, scoreInfo.Mods).ToArray());
+                var difficultyAttributes = difficultyCalculator.Calculate(LegacyHelper.ConvertToLegacyDifficultyAdjustmentMods(ruleset, scoreInfo.Mods).ToArray());
                 var performanceCalculator = ruleset.CreatePerformanceCalculator(difficultyAttributes, score.ScoreInfo);
 
                 var ppAttributes = performanceCalculator?.Calculate();
diff --git a/PerformanceCalculator/Simulate/SimulateCommand.cs b/PerformanceCalculator/Simulate/SimulateCommand.cs
index ffaf320..7232a09 100644
--- a/PerformanceCalculator/Simulate/SimulateCommand.cs
+++ b/PerformanceCalculator/Simulate/SimulateCommand.cs
@@ -74,7 +74,7 @@ namespace PerformanceCalculator.Simulate
             var accuracy = GetAccuracy(statistics);
 
             var difficultyCalculator = ruleset.CreateDifficultyCalculator(workingBeatmap);
-            var difficultyAttributes = difficultyCalculator.Calculate(LegacyHelper.TrimNonDifficultyAdjustmentMods(ruleset, mods).ToArray());
+            var difficultyAttributes = difficultyCalculator.Calculate(LegacyHelper.ConvertToLegacyDifficultyAdjustmentMods(ruleset, mods).ToArray());
             var performanceCalculator = ruleset.CreatePerformanceCalculator(difficultyAttributes, new ScoreInfo(beatmap.BeatmapInfo, ruleset.RulesetInfo)
             {
                 Accuracy = accuracy,