diff --git a/rslib/src/scheduler/states/mod.rs b/rslib/src/scheduler/states/mod.rs
index 3bd977183..44b6760f8 100644
--- a/rslib/src/scheduler/states/mod.rs
+++ b/rslib/src/scheduler/states/mod.rs
@@ -158,7 +158,7 @@ fn constrained_fuzz_bounds(interval: f32, minimum: u32, maximum: u32) -> (u32, u
     lower = lower.max(minimum).min(maximum);
     upper = upper.max(minimum).min(maximum);
 
-    if upper == lower && upper > 1 && upper < maximum {
+    if upper == lower && upper > 2 && upper < maximum {
         upper = lower + 1;
     };
 
@@ -166,10 +166,9 @@ fn constrained_fuzz_bounds(interval: f32, minimum: u32, maximum: u32) -> (u32, u
 }
 
 fn fuzz_bounds(interval: f32) -> (u32, u32) {
-    if interval < 2.0 {
-        (1, 1)
-    } else if interval < 3.0 {
-        (2, 3)
+    if interval < 2.5 {
+        let rounded = interval.round().max(1.0) as u32;
+        (rounded, rounded)
     } else if interval < 7.0 {
         fuzz_range(interval, 0.25, 0.0)
     } else if interval < 30.0 {
@@ -254,23 +253,6 @@ mod test {
         assert_eq!(ctx.min_and_max_review_intervals(4), (3, 3));
     }
 
-    fn assert_lower_middle_upper(
-        ctx: &mut StateContext,
-        interval: f32,
-        minimum: u32,
-        maximum: u32,
-        lower: u32,
-        middle: u32,
-        upper: u32,
-    ) {
-        ctx.fuzz_factor = Some(0.0);
-        assert_eq!(ctx.with_review_fuzz(interval, minimum, maximum), lower);
-        ctx.fuzz_factor = Some(0.5);
-        assert_eq!(ctx.with_review_fuzz(interval, minimum, maximum), middle);
-        ctx.fuzz_factor = Some(0.99);
-        assert_eq!(ctx.with_review_fuzz(interval, minimum, maximum), upper);
-    }
-
     #[test]
     fn with_review_fuzz() {
         let mut ctx = StateContext::defaults_for_testing();
@@ -280,23 +262,41 @@ mod test {
         assert_eq!(ctx.with_review_fuzz(0.1, 1, 100), 1);
         assert_eq!(ctx.with_review_fuzz(101.0, 1, 100), 100);
 
-        // no fuzzing for an interval of 1
-        assert_lower_middle_upper(&mut ctx, 1.0, 1, 1000, 1, 1, 1);
-        // fuzz range is (2, 3) for an interval of 2
-        assert_lower_middle_upper(&mut ctx, 2.0, 1, 1000, 2, 3, 3);
+        macro_rules! assert_lower_middle_upper {
+            ($interval:expr, $minimum:expr, $maximum:expr, $lower:expr, $middle:expr, $upper:expr) => {{
+                ctx.fuzz_factor = Some(0.0);
+                assert_eq!(ctx.with_review_fuzz($interval, $minimum, $maximum), $lower);
+                ctx.fuzz_factor = Some(0.5);
+                assert_eq!(ctx.with_review_fuzz($interval, $minimum, $maximum), $middle);
+                ctx.fuzz_factor = Some(0.99);
+                assert_eq!(ctx.with_review_fuzz($interval, $minimum, $maximum), $upper);
+            }};
+        }
+
+        // no fuzzing for an interval of 1-2.49
+        assert_lower_middle_upper!(1.0, 1, 1000, 1, 1, 1);
+        assert_lower_middle_upper!(2.49, 1, 1000, 2, 2, 2);
         // 25%, 15%, 5% percent fuzz, but at least 1, 2, 4
-        assert_lower_middle_upper(&mut ctx, 5.0, 1, 1000, 4, 5, 6);
-        assert_lower_middle_upper(&mut ctx, 20.0, 1, 1000, 17, 20, 23);
-        assert_lower_middle_upper(&mut ctx, 100.0, 1, 1000, 95, 100, 105);
+        assert_lower_middle_upper!(5.0, 1, 1000, 4, 5, 6);
+        assert_lower_middle_upper!(20.0, 1, 1000, 17, 20, 23);
+        assert_lower_middle_upper!(100.0, 1, 1000, 95, 100, 105);
 
         // ensure fuzz range of at least 2, if allowed
-        assert_lower_middle_upper(&mut ctx, 2.0, 2, 1000, 2, 3, 3);
-        assert_lower_middle_upper(&mut ctx, 2.0, 3, 1000, 3, 4, 4);
-        assert_lower_middle_upper(&mut ctx, 2.0, 3, 3, 3, 3, 3);
+        assert_lower_middle_upper!(2.0, 2, 1000, 2, 2, 2);
+        assert_lower_middle_upper!(2.0, 3, 1000, 3, 4, 4);
+        assert_lower_middle_upper!(2.0, 3, 3, 3, 3, 3);
+
+        // fuzz bracket transitions
+        assert_lower_middle_upper!(6.9, 3, 1000, 5, 7, 9);
+        assert_lower_middle_upper!(7.0, 3, 1000, 5, 7, 9);
+        assert_lower_middle_upper!(7.1, 3, 1000, 5, 7, 9);
+        assert_lower_middle_upper!(29.9, 3, 1000, 25, 30, 34);
+        assert_lower_middle_upper!(30.0, 3, 1000, 26, 30, 34);
+        assert_lower_middle_upper!(30.1, 3, 1000, 26, 30, 34);
 
         // respect limits and preserve uniform distribution of valid intervals
-        assert_lower_middle_upper(&mut ctx, 100.0, 101, 1000, 101, 103, 105);
-        assert_lower_middle_upper(&mut ctx, 100.0, 1, 99, 95, 97, 99);
-        assert_lower_middle_upper(&mut ctx, 100.0, 97, 103, 97, 100, 103);
+        assert_lower_middle_upper!(100.0, 101, 1000, 101, 103, 105);
+        assert_lower_middle_upper!(100.0, 1, 99, 95, 97, 99);
+        assert_lower_middle_upper!(100.0, 97, 103, 97, 100, 103);
     }
 }
diff --git a/rslib/src/scheduler/states/review.rs b/rslib/src/scheduler/states/review.rs
index 986fec254..11dad02c6 100644
--- a/rslib/src/scheduler/states/review.rs
+++ b/rslib/src/scheduler/states/review.rs
@@ -272,7 +272,7 @@ mod test {
         ctx.interval_multiplier = 0.1;
         assert_eq!(state.passing_review_intervals(&ctx), (2, 3, 4));
         ctx.fuzz_factor = Some(0.99);
-        assert_eq!(state.passing_review_intervals(&ctx), (3, 5, 7));
+        assert_eq!(state.passing_review_intervals(&ctx), (2, 4, 6));
 
         // maximum must be respected no matter what
         ctx.interval_multiplier = 10.0;