diff --git a/video/config/BUILD.gn b/video/config/BUILD.gn
index aef6c7453c..4c20e02f55 100644
--- a/video/config/BUILD.gn
+++ b/video/config/BUILD.gn
@@ -71,6 +71,7 @@ if (rtc_include_tests) {
       ":streams_config",
       "../../call/adaptation:resource_adaptation",
       "../../media:media_constants",
+      "../../rtc_base/experiments:min_video_bitrate_experiment",
       "../../test:explicit_key_value_config",
       "../../test:test_support",
     ]
diff --git a/video/config/encoder_stream_factory.cc b/video/config/encoder_stream_factory.cc
index 54dff93cc8..7dd53ab389 100644
--- a/video/config/encoder_stream_factory.cc
+++ b/video/config/encoder_stream_factory.cc
@@ -320,23 +320,24 @@ EncoderStreamFactory::CreateSimulcastOrConferenceModeScreenshareStreams(
     const absl::optional<webrtc::DataRate>& experimental_min_bitrate) const {
   bool is_screencast = encoder_config.content_type ==
                        webrtc::VideoEncoderConfig::ContentType::kScreen;
+  const bool is_legacy_screencast =
+      webrtc::SimulcastUtility::IsConferenceModeScreenshare(encoder_config);
   std::vector<webrtc::VideoStream> layers;
 
   const bool temporal_layers_supported =
       IsTemporalLayersSupported(encoder_config.codec_type);
   // Use legacy simulcast screenshare if conference mode is explicitly enabled
   // or use the regular simulcast configuration path which is generic.
-  layers = GetSimulcastConfig(
-      FindRequiredActiveLayers(encoder_config),
-      encoder_config.number_of_streams, width, height,
-      webrtc::SimulcastUtility::IsConferenceModeScreenshare(encoder_config),
-      temporal_layers_supported, trials, encoder_config.codec_type);
+  layers = GetSimulcastConfig(FindRequiredActiveLayers(encoder_config),
+                              encoder_config.number_of_streams, width, height,
+                              is_legacy_screencast, temporal_layers_supported,
+                              trials, encoder_config.codec_type);
   // Allow an experiment to override the minimum bitrate for the lowest
   // spatial layer. The experiment's configuration has the lowest priority.
-  if (experimental_min_bitrate) {
-    layers[0].min_bitrate_bps =
-        rtc::saturated_cast<int>(experimental_min_bitrate->bps());
-  }
+  layers[0].min_bitrate_bps = experimental_min_bitrate
+                                  .value_or(webrtc::DataRate::BitsPerSec(
+                                      webrtc::kDefaultMinVideoBitrateBps))
+                                  .bps<int>();
 
   const bool has_scale_resolution_down_by = absl::c_any_of(
       encoder_config.simulcast_layers, [](const webrtc::VideoStream& layer) {
diff --git a/video/config/encoder_stream_factory_unittest.cc b/video/config/encoder_stream_factory_unittest.cc
index f095a086d6..7daf0b2eea 100644
--- a/video/config/encoder_stream_factory_unittest.cc
+++ b/video/config/encoder_stream_factory_unittest.cc
@@ -11,14 +11,17 @@
 #include "video/config/encoder_stream_factory.h"
 
 #include "call/adaptation/video_source_restrictions.h"
+#include "rtc_base/experiments/min_video_bitrate_experiment.h"
 #include "test/explicit_key_value_config.h"
+#include "test/gmock.h"
 #include "test/gtest.h"
 
 namespace webrtc {
 namespace {
-
 using ::cricket::EncoderStreamFactory;
 using test::ExplicitKeyValueConfig;
+using ::testing::IsEmpty;
+using ::testing::Not;
 
 std::vector<Resolution> GetStreamResolutions(
     const std::vector<VideoStream>& streams) {
@@ -96,4 +99,30 @@ TEST(EncoderStreamFactory, BitratePriority) {
   EXPECT_EQ(streams[0].bitrate_priority, kBitratePriority);
   EXPECT_FALSE(streams[1].bitrate_priority);
 }
+
+TEST(EncoderStreamFactory, SetsMinBitrateToDefaultValue) {
+  VideoEncoder::EncoderInfo encoder_info;
+  auto factory = rtc::make_ref_counted<EncoderStreamFactory>(encoder_info);
+  VideoEncoderConfig encoder_config;
+  encoder_config.number_of_streams = 2;
+  encoder_config.simulcast_layers.resize(encoder_config.number_of_streams);
+  auto streams = factory->CreateEncoderStreams(ExplicitKeyValueConfig(""), 1920,
+                                               1080, encoder_config);
+  ASSERT_THAT(streams, Not(IsEmpty()));
+  EXPECT_EQ(streams[0].min_bitrate_bps, kDefaultMinVideoBitrateBps);
+}
+
+TEST(EncoderStreamFactory, SetsMinBitrateToExperimentalValue) {
+  VideoEncoder::EncoderInfo encoder_info;
+  auto factory = rtc::make_ref_counted<EncoderStreamFactory>(encoder_info);
+  VideoEncoderConfig encoder_config;
+  encoder_config.number_of_streams = 2;
+  encoder_config.simulcast_layers.resize(encoder_config.number_of_streams);
+  auto streams = factory->CreateEncoderStreams(
+      ExplicitKeyValueConfig("WebRTC-Video-MinVideoBitrate/Enabled,br:1kbps/"),
+      1920, 1080, encoder_config);
+  ASSERT_THAT(streams, Not(IsEmpty()));
+  EXPECT_NE(streams[0].min_bitrate_bps, kDefaultMinVideoBitrateBps);
+  EXPECT_EQ(streams[0].min_bitrate_bps, 1000);
+}
 }  // namespace webrtc