diff --git a/src/Lynx/EvaluationConstants.cs b/src/Lynx/EvaluationConstants.cs
index a1a934acc..583139a91 100644
--- a/src/Lynx/EvaluationConstants.cs
+++ b/src/Lynx/EvaluationConstants.cs
@@ -89,17 +89,17 @@ static EvaluationConstants()
     /// <summary>
     /// Base absolute checkmate evaluation value. Actual absolute evaluations are lower than this one by a number of <see cref="Position.DepthCheckmateFactor"/>
     /// </summary>
-    public const int CheckMateBaseEvaluation = 30_000;
+    public const int CheckMateBaseEvaluation = 29_000;
 
     /// <summary>
     /// Max eval, including checkmate values
     /// </summary>
-    public const int MaxEval = CheckMateBaseEvaluation + 1;
+    public const int MaxEval = 32_000;  // CheckMateBaseEvaluation + (Constants.AbsoluteMaxDepth + 45) * DepthCheckmateFactor;
 
     /// <summary>
     /// Min eval, including checkmate values
     /// </summary>
-    public const int MinEval = -CheckMateBaseEvaluation - 1;
+    public const int MinEval = -32_000;    // -CheckMateBaseEvaluation - (Constants.AbsoluteMaxDepth + 45) * DepthCheckmateFactor;
 
     /// <summary>
     /// This value combined with <see cref="PositiveCheckmateDetectionLimit"/> and <see cref="NegativeCheckmateDetectionLimit"/> should allows mates up to in <see cref="Constants.AbsoluteMaxDepth"/> moves.
@@ -109,12 +109,12 @@ static EvaluationConstants()
     /// <summary>
     /// Minimum evaluation for a position to be White checkmate
     /// </summary>
-    public const int PositiveCheckmateDetectionLimit = 27_000; // CheckMateBaseEvaluation - (Constants.AbsoluteMaxDepth + 45) * DepthCheckmateFactor;
+    public const int PositiveCheckmateDetectionLimit = 26_000; // CheckMateBaseEvaluation - (Constants.AbsoluteMaxDepth + 45) * DepthCheckmateFactor;
 
     /// <summary>
     /// Minimum evaluation for a position to be Black checkmate
     /// </summary>
-    public const int NegativeCheckmateDetectionLimit = -27_000; // -CheckMateBaseEvaluation + (Constants.AbsoluteMaxDepth + 45) * DepthCheckmateFactor;
+    public const int NegativeCheckmateDetectionLimit = -26_000; // -CheckMateBaseEvaluation + (Constants.AbsoluteMaxDepth + 45) * DepthCheckmateFactor;
 
     /// <summary>
     /// Max static eval. It doesn't include checkmate values and it's below <see cref="PositiveCheckmateDetectionLimit"/>
@@ -126,6 +126,16 @@ static EvaluationConstants()
     /// </summary>
     public const int MinStaticEval = NegativeCheckmateDetectionLimit + 1;
 
+    /// <summary>
+    /// Outside of the evaluation ranges (higher than any sensible evaluation, lower than <see cref="PositiveCheckmateDetectionLimit"/>)
+    /// </summary>
+    public const int NoHashEntry = 25_000;
+
+    /// <summary>
+    /// Evaluation to be returned when there's one single legal move
+    /// </summary>
+    public const int SingleMoveScore = 200;
+
     #region Move ordering
 
     public const int TTMoveScoreValue = 2_097_152;
@@ -156,16 +166,6 @@ static EvaluationConstants()
 
     #endregion
 
-    /// <summary>
-    /// Outside of the evaluation ranges (higher than any sensible evaluation, lower than <see cref="PositiveCheckmateDetectionLimit"/>)
-    /// </summary>
-    public const int NoHashEntry = 25_000;
-
-    /// <summary>
-    /// Evaluation to be returned when there's one single legal move
-    /// </summary>
-    public const int SingleMoveScore = 200;
-
     public const int ContinuationHistoryPlyCount = 1;
 }
 
diff --git a/tests/Lynx.Test/EvaluationConstantsTest.cs b/tests/Lynx.Test/EvaluationConstantsTest.cs
index 77f9eedd7..b6f2f299f 100644
--- a/tests/Lynx.Test/EvaluationConstantsTest.cs
+++ b/tests/Lynx.Test/EvaluationConstantsTest.cs
@@ -47,12 +47,14 @@ public void NegativeCheckmateDetectionLimitTest()
     public void MaxEvalTest()
     {
         Assert.Greater(MaxEval, PositiveCheckmateDetectionLimit + ((Constants.AbsoluteMaxDepth + 10) * CheckmateDepthFactor));
+        Assert.Less(MaxEval, short.MaxValue);
     }
 
     [Test]
     public void MinEvalTest()
     {
         Assert.Less(MinEval, NegativeCheckmateDetectionLimit - ((Constants.AbsoluteMaxDepth + 10) * CheckmateDepthFactor));
+        Assert.Greater(MinEval, short.MinValue);
     }
 
     [Test]