diff --git a/utils/rate_test.go b/utils/rate_test.go
index 961234c0..ebe01cbf 100644
--- a/utils/rate_test.go
+++ b/utils/rate_test.go
@@ -132,6 +132,7 @@ type testRunner interface {
 	// assertCountAt asserts the limiters have Taken() a number of times at the given time.
 	// It's a thin wrapper around afterFunc to reduce boilerplate code.
 	assertCountAt(d time.Duration, count int)
+	assertCountAtWithNoise(d time.Duration, count int, noise int)
 	// afterFunc executes a func at a given time.
 	// not using clock.AfterFunc because andres-erbsen/clock misses a nap there.
 	afterFunc(d time.Duration, fn func())
@@ -191,7 +192,22 @@ func runTest(t *testing.T, fn func(testRunner)) {
 			defer r.wg.Wait()
 
 			fn(&r)
-			r.clock.Add(r.maxDuration)
+
+			// it's possible that there are some goroutines still waiting
+			// in taking the bandwidth. We need to keep moving the clock forward
+			// until all goroutines are finished
+			go func() {
+				ticker := time.NewTicker(5 * time.Millisecond)
+				defer ticker.Stop()
+
+				for {
+					select {
+					case <-ticker.C:
+						r.clock.Add(r.maxDuration)
+					case <-r.doneCh:
+					}
+				}
+			}()
 		})
 	}
 }
@@ -242,6 +258,19 @@ func (r *runnerImpl) assertCountAt(d time.Duration, count int) {
 	})
 }
 
+// assertCountAtWithNoise like assertCountAt but also considers possible noise in CI
+func (r *runnerImpl) assertCountAtWithNoise(d time.Duration, count int, noise int) {
+	r.wg.Add(1)
+	r.afterFunc(d, func() {
+		actual := int(r.count.Load())
+		boundMin, boundMax := count-noise, count+noise
+		withinRange := boundMin < actual && actual < boundMax
+		assert.True(r.t, withinRange, "expected count to be within [%d, %d], but got %d",
+			boundMin, boundMax, actual)
+		r.wg.Done()
+	})
+}
+
 // afterFunc executes a func at a given time.
 func (r *runnerImpl) afterFunc(d time.Duration, fn func()) {
 	if d > r.maxDuration {
@@ -270,7 +299,6 @@ func (r *runnerImpl) goWait(fn func()) {
 }
 
 func TestRateLimiter(t *testing.T) {
-	t.Parallel()
 	runTest(t, func(r testRunner) {
 		rl := r.createLimiter(100, WithoutSlack)
 
@@ -280,15 +308,14 @@ func TestRateLimiter(t *testing.T) {
 		r.startTaking(rl)
 		r.startTaking(rl)
 
-		r.assertCountAt(1*time.Second, 100)
-		r.assertCountAt(2*time.Second, 200)
-		r.assertCountAt(3*time.Second, 300)
+		r.assertCountAtWithNoise(1*time.Second, 100, 2)
+		r.assertCountAtWithNoise(2*time.Second, 200, 2)
+		r.assertCountAtWithNoise(3*time.Second, 300, 2)
 	})
 }
 
 func TestDelayedRateLimiter(t *testing.T) {
 	t.Skip(UnstableTest)
-	t.Parallel()
 	runTest(t, func(r testRunner) {
 		slow := r.createLimiter(10, WithoutSlack)
 		fast := r.createLimiter(100, WithoutSlack)
@@ -307,7 +334,6 @@ func TestDelayedRateLimiter(t *testing.T) {
 }
 
 func TestPer(t *testing.T) {
-	t.Parallel()
 	runTest(t, func(r testRunner) {
 		rl := r.createLimiter(7, WithoutSlack, Per(time.Minute))
 
@@ -322,7 +348,6 @@ func TestPer(t *testing.T) {
 
 // TestInitial verifies that the initial sequence is scheduled as expected.
 func TestInitial(t *testing.T) {
-	t.Parallel()
 	tests := []struct {
 		msg  string
 		opts []Option
@@ -339,27 +364,25 @@ func TestInitial(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.msg, func(t *testing.T) {
 			runTest(t, func(r testRunner) {
+				perRequest := 100 * time.Millisecond
 				rl := r.createLimiter(10, tt.opts...)
 
 				var (
 					clk  = r.getClock()
 					prev = clk.Now()
 
-					results = make(chan time.Time)
+					results = make(chan time.Time, 3)
 					have    []time.Duration
-					startWg sync.WaitGroup
 				)
-				startWg.Add(3)
 
-				for i := 0; i < 3; i++ {
-					go func() {
-						startWg.Done()
-						results <- rl.Take()
-					}()
-				}
+				results <- rl.Take()
+				clk.Add(perRequest)
 
-				startWg.Wait()
-				clk.Add(time.Second)
+				results <- rl.Take()
+				clk.Add(perRequest)
+
+				results <- rl.Take()
+				clk.Add(perRequest)
 
 				for i := 0; i < 3; i++ {
 					ts := <-results
@@ -370,8 +393,8 @@ func TestInitial(t *testing.T) {
 				assert.Equal(t,
 					[]time.Duration{
 						0,
-						time.Millisecond * 100,
-						time.Millisecond * 100,
+						perRequest,
+						perRequest,
 					},
 					have,
 					"bad timestamps for inital takes",
@@ -382,23 +405,34 @@ func TestInitial(t *testing.T) {
 }
 
 func TestMaxSlack(t *testing.T) {
-	t.Parallel()
 	runTest(t, func(r testRunner) {
+		clock := r.getClock()
 		rl := r.createLimiter(1, WithSlack(1))
+		rl.Take()
+		clock.Add(time.Second)
+		rl.Take()
+		clock.Add(time.Second)
+		rl.Take()
 
-		r.takeOnceAfter(time.Nanosecond, rl)
-		r.takeOnceAfter(2*time.Second+1*time.Nanosecond, rl)
-		r.takeOnceAfter(2*time.Second+2*time.Nanosecond, rl)
-		r.takeOnceAfter(2*time.Second+3*time.Nanosecond, rl)
-		r.takeOnceAfter(2*time.Second+4*time.Nanosecond, rl)
+		doneCh := make(chan struct{})
+		go func() {
+			rl.Take()
+			close(doneCh)
+		}()
 
-		r.assertCountAt(3*time.Second, 3)
-		r.assertCountAt(10*time.Second, 5)
+		select {
+		case <-doneCh:
+			require.Fail(t, "expect rate limiter to be waiting")
+		case <-time.After(time.Millisecond):
+			// clean up ratelimiter waiting for take
+			clock.Add(time.Second)
+		}
 	})
 }
 
 func TestSlack(t *testing.T) {
-	t.Parallel()
+	t.Skip(UnstableTest)
+
 	// To simulate slack, we combine two limiters.
 	// - First, we start a single goroutine with both of them,
 	//   during this time the slow limiter will dominate,
@@ -469,11 +503,6 @@ func TestSlack(t *testing.T) {
 	}
 
 	for _, tt := range tests {
-		cfg := buildConfig(tt.opt)
-		if cfg.slack >= 100 {
-			t.Skip(UnstableTest)
-		}
-
 		t.Run(tt.msg, func(t *testing.T) {
 			runTest(t, func(r testRunner) {
 				slow := r.createLimiter(10, WithoutSlack)
@@ -487,8 +516,8 @@ func TestSlack(t *testing.T) {
 				})
 
 				// limiter with 10hz dominates here - we're always at 10.
-				r.assertCountAt(1*time.Second, 10)
-				r.assertCountAt(3*time.Second, tt.want)
+				r.assertCountAtWithNoise(1*time.Second, 10, 2)
+				r.assertCountAtWithNoise(3*time.Second, tt.want, 2)
 			})
 		})
 	}