diff --git a/video/end_to_end_tests/resolution_bitrate_limits_tests.cc b/video/end_to_end_tests/resolution_bitrate_limits_tests.cc
index 89d4a9aab0..2ee1589c07 100644
--- a/video/end_to_end_tests/resolution_bitrate_limits_tests.cc
+++ b/video/end_to_end_tests/resolution_bitrate_limits_tests.cc
@@ -348,7 +348,7 @@ TEST_P(ResolutionBitrateLimitsTest, LimitsAppliedMiddleActive) {
   RunBaseTest(&test);
 }
 
-TEST_P(ResolutionBitrateLimitsTest, IntersectionAppliedMiddleActive) {
+TEST_P(ResolutionBitrateLimitsTest, EncodingMinBitrateAppliedMiddleActive) {
   webrtc::test::ScopedFieldTrials field_trials(
       "WebRTC-GetEncoderInfoOverride/"
       "frame_size_pixels:230400|921600,"
@@ -356,15 +356,18 @@ TEST_P(ResolutionBitrateLimitsTest, IntersectionAppliedMiddleActive) {
       "min_bitrate_bps:31000|32000,"
       "max_bitrate_bps:2222000|3333000/");
 
+  // Max bitrate: min of encoding and bitrate limits used.
   InitEncodeTest test(env(), payload_name_,
-                      {{.active = false},
+                      {{.active = false,
+                        .bitrate = {DataRate::KilobitsPerSec(28),
+                                    DataRate::KilobitsPerSec(1000)}},
                        {.active = true,
-                        .bitrate = {DataRate::KilobitsPerSec(30),
+                        .bitrate = {DataRate::KilobitsPerSec(28),
                                     DataRate::KilobitsPerSec(1555)}},
                        {.active = false}},
                       // Expectations:
                       {{.pixels = 640 * 360,
-                        .eq_bitrate = {DataRate::KilobitsPerSec(31),
+                        .eq_bitrate = {DataRate::KilobitsPerSec(28),
                                        DataRate::KilobitsPerSec(1555)}}});
   RunBaseTest(&test);
 }
@@ -424,7 +427,7 @@ TEST_P(ResolutionBitrateLimitsTest, LimitsAppliedHighestActive) {
   RunBaseTest(&test);
 }
 
-TEST_P(ResolutionBitrateLimitsTest, IntersectionAppliedHighestActive) {
+TEST_P(ResolutionBitrateLimitsTest, EncodingMinBitrateAppliedHighestActive) {
   webrtc::test::ScopedFieldTrials field_trials(
       "WebRTC-GetEncoderInfoOverride/"
       "frame_size_pixels:230400|921600,"
@@ -432,15 +435,20 @@ TEST_P(ResolutionBitrateLimitsTest, IntersectionAppliedHighestActive) {
       "min_bitrate_bps:31000|32000,"
       "max_bitrate_bps:2222000|3333000/");
 
+  // Max bitrate: min of encoding and bitrate limits used.
   InitEncodeTest test(env(), payload_name_,
-                      {{.active = false},
-                       {.active = false},
+                      {{.active = false,
+                        .bitrate = {DataRate::KilobitsPerSec(28),
+                                    DataRate::KilobitsPerSec(500)}},
+                       {.active = false,
+                        .bitrate = {DataRate::KilobitsPerSec(28),
+                                    DataRate::KilobitsPerSec(1000)}},
                        {.active = true,
-                        .bitrate = {DataRate::KilobitsPerSec(30),
+                        .bitrate = {DataRate::KilobitsPerSec(28),
                                     DataRate::KilobitsPerSec(1555)}}},
                       // Expectations:
                       {{.pixels = 1280 * 720,
-                        .eq_bitrate = {DataRate::KilobitsPerSec(32),
+                        .eq_bitrate = {DataRate::KilobitsPerSec(28),
                                        DataRate::KilobitsPerSec(1555)}}});
   RunBaseTest(&test);
 }
@@ -528,7 +536,7 @@ TEST_F(ResolutionBitrateLimitsWithScalabilityModeTest,
 }
 
 TEST_F(ResolutionBitrateLimitsWithScalabilityModeTest,
-       LimitsAppliedForAv1Simulcast) {
+       LimitsAppliedForAv1SingleSpatialLayer) {
   webrtc::test::ScopedFieldTrials field_trials(
       "WebRTC-GetEncoderInfoOverride/"
       "frame_size_pixels:230400|921600,"
@@ -547,6 +555,29 @@ TEST_F(ResolutionBitrateLimitsWithScalabilityModeTest,
   RunBaseTest(&test);
 }
 
+TEST_F(ResolutionBitrateLimitsWithScalabilityModeTest,
+       EncodingMinBitrateAppliedForAv1SingleSpatialLayer) {
+  webrtc::test::ScopedFieldTrials field_trials(
+      "WebRTC-GetEncoderInfoOverride/"
+      "frame_size_pixels:921600,"
+      "min_start_bitrate_bps:0,"
+      "min_bitrate_bps:32000,"
+      "max_bitrate_bps:133000/");
+
+  // Max bitrate: min of encoding and bitrate limits used.
+  InitEncodeTest test(env(), "AV1",
+                      {{.active = true,
+                        .bitrate = {DataRate::KilobitsPerSec(28),
+                                    DataRate::KilobitsPerSec(100)},
+                        .scalability_mode = ScalabilityMode::kL1T1},
+                       {.active = false}},
+                      // Expectations:
+                      {{.pixels = 1280 * 720,
+                        .eq_bitrate = {DataRate::KilobitsPerSec(28),
+                                       DataRate::KilobitsPerSec(100)}}});
+  RunBaseTest(&test);
+}
+
 TEST_F(ResolutionBitrateLimitsWithScalabilityModeTest,
        LimitsNotAppliedForAv1MultipleSpatialLayers) {
   webrtc::test::ScopedFieldTrials field_trials(
diff --git a/video/video_stream_encoder.cc b/video/video_stream_encoder.cc
index 5c04481bec..250edc16b3 100644
--- a/video/video_stream_encoder.cc
+++ b/video/video_stream_encoder.cc
@@ -426,9 +426,7 @@ void ApplySpatialLayerBitrateLimits(
   if (encoder_config.simulcast_layers[*index].min_bitrate_bps <= 0) {
     min_bitrate_bps = bitrate_limits->min_bitrate_bps;
   } else {
-    min_bitrate_bps =
-        std::max(bitrate_limits->min_bitrate_bps,
-                 encoder_config.simulcast_layers[*index].min_bitrate_bps);
+    min_bitrate_bps = encoder_config.simulcast_layers[*index].min_bitrate_bps;
   }
   int max_bitrate_bps;
   if (encoder_config.simulcast_layers[*index].max_bitrate_bps <= 0) {
@@ -487,13 +485,11 @@ void ApplyEncoderBitrateLimitsIfSingleActiveStream(
     return;
   }
 
-  // If bitrate limits are set by RtpEncodingParameters, use intersection.
   int min_bitrate_bps;
   if (encoder_config_layers[index].min_bitrate_bps <= 0) {
     min_bitrate_bps = encoder_bitrate_limits->min_bitrate_bps;
   } else {
-    min_bitrate_bps = std::max(encoder_bitrate_limits->min_bitrate_bps,
-                               (*streams)[index].min_bitrate_bps);
+    min_bitrate_bps = (*streams)[index].min_bitrate_bps;
   }
   int max_bitrate_bps;
   if (encoder_config_layers[index].max_bitrate_bps <= 0) {