diff --git a/experiments/field_trials.py b/experiments/field_trials.py
index ed192a6..a179681 100755
--- a/experiments/field_trials.py
+++ b/experiments/field_trials.py
@@ -829,9 +829,6 @@
     FieldTrial('WebRTC-Video-BalancedDegradationSettings',
                NO_BUG,
                INDEFINITE),
-    FieldTrial('WebRTC-Video-BandwidthQualityScalerSettings',
-               42223115,
-               INDEFINITE),
     FieldTrial('WebRTC-Video-DisableAutomaticResize',
                42221931,
                date(2024, 4, 1)),
@@ -893,7 +890,7 @@
 ])  # yapf: disable
 
 POLICY_EXEMPT_FIELD_TRIALS_DIGEST: str = \
-    '263c7a29291a7c4472ff60c7c3b2520f6dd5cea8'
+    'f74a8c7f29f03ef83154393d0a7ea0b7258d7441'
 
 REGISTERED_FIELD_TRIALS: FrozenSet[FieldTrial] = ACTIVE_FIELD_TRIALS.union(
     POLICY_EXEMPT_FIELD_TRIALS)
diff --git a/modules/video_coding/BUILD.gn b/modules/video_coding/BUILD.gn
index 00b8236..d2246d5 100644
--- a/modules/video_coding/BUILD.gn
+++ b/modules/video_coding/BUILD.gn
@@ -443,7 +443,6 @@
     "../../rtc_base:stringutils",
     "../../rtc_base:timeutils",
     "../../rtc_base:weak_ptr",
-    "../../rtc_base/experiments:bandwidth_quality_scaler_settings",
     "../../rtc_base/experiments:encoder_info_settings",
     "../../rtc_base/experiments:quality_scaler_settings",
     "../../rtc_base/experiments:quality_scaling_experiment",
diff --git a/modules/video_coding/utility/bandwidth_quality_scaler.cc b/modules/video_coding/utility/bandwidth_quality_scaler.cc
index 13502a1..f81ae3b 100644
--- a/modules/video_coding/utility/bandwidth_quality_scaler.cc
+++ b/modules/video_coding/utility/bandwidth_quality_scaler.cc
@@ -18,7 +18,6 @@
 #include "api/video/video_adaptation_reason.h"
 #include "api/video_codecs/video_encoder.h"
 #include "rtc_base/checks.h"
-#include "rtc_base/experiments/bandwidth_quality_scaler_settings.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/numerics/exp_filter.h"
 #include "rtc_base/time_utils.h"
@@ -31,16 +30,11 @@
 constexpr int kDefaultMaxWindowSizeMs = 5000;
 constexpr float kHigherMaxBitrateTolerationFactor = 0.95;
 constexpr float kLowerMinBitrateTolerationFactor = 0.8;
-constexpr int kDefaultBitrateStateUpdateIntervalSeconds = 5;
 }  // namespace
 
 BandwidthQualityScaler::BandwidthQualityScaler(
     BandwidthQualityScalerUsageHandlerInterface* handler)
-    : kBitrateStateUpdateInterval(TimeDelta::Seconds(
-          BandwidthQualityScalerSettings::ParseFromFieldTrials()
-              .BitrateStateUpdateInterval()
-              .value_or(kDefaultBitrateStateUpdateIntervalSeconds))),
-      handler_(handler),
+    : handler_(handler),
       encoded_bitrate_(kDefaultMaxWindowSizeMs, RateStatistics::kBpsScale),
       weak_ptr_factory_(this) {
   RTC_DCHECK_RUN_ON(&task_checker_);
diff --git a/modules/video_coding/utility/bandwidth_quality_scaler.h b/modules/video_coding/utility/bandwidth_quality_scaler.h
index 7cd1de0..89e171c 100644
--- a/modules/video_coding/utility/bandwidth_quality_scaler.h
+++ b/modules/video_coding/utility/bandwidth_quality_scaler.h
@@ -46,6 +46,9 @@
 // stream down or up).
 class BandwidthQualityScaler {
  public:
+  static constexpr TimeDelta kBitrateStateUpdateInterval =
+      TimeDelta::Seconds(5);
+
   explicit BandwidthQualityScaler(
       BandwidthQualityScalerUsageHandlerInterface* handler);
   virtual ~BandwidthQualityScaler();
@@ -62,8 +65,6 @@
       const std::vector<VideoEncoder::ResolutionBitrateLimits>&
           resolution_bitrate_limits);
 
-  const TimeDelta kBitrateStateUpdateInterval;
-
  private:
   enum class CheckBitrateResult {
     kInsufficientSamples,
diff --git a/modules/video_coding/utility/bandwidth_quality_scaler_unittest.cc b/modules/video_coding/utility/bandwidth_quality_scaler_unittest.cc
index 4e2c759..67620e4 100644
--- a/modules/video_coding/utility/bandwidth_quality_scaler_unittest.cc
+++ b/modules/video_coding/utility/bandwidth_quality_scaler_unittest.cc
@@ -19,15 +19,15 @@
 #include "rtc_base/experiments/encoder_info_settings.h"
 #include "rtc_base/task_queue_for_test.h"
 #include "rtc_base/time_utils.h"
-#include "test/field_trial.h"
 #include "test/gtest.h"
+#include "test/time_controller/simulated_time_controller.h"
 
 namespace webrtc {
 
 namespace {
 constexpr int kFramerateFps = 30;
-constexpr TimeDelta kDefaultBitrateStateUpdateInterval = TimeDelta::Seconds(5);
 constexpr TimeDelta kDefaultEncodeTime = TimeDelta::Seconds(1) / kFramerateFps;
+constexpr TimeDelta kWaitTime = TimeDelta::Millis(200);
 
 }  // namespace
 
@@ -50,20 +50,7 @@
   int adapt_down_event_count_ = 0;
 };
 
-class BandwidthQualityScalerUnderTest : public BandwidthQualityScaler {
- public:
-  explicit BandwidthQualityScalerUnderTest(
-      BandwidthQualityScalerUsageHandlerInterface* handler)
-      : BandwidthQualityScaler(handler) {}
-
-  int GetBitrateStateUpdateIntervalMs() {
-    return this->kBitrateStateUpdateInterval.ms() + 200;
-  }
-};
-
-class BandwidthQualityScalerTest
-    : public ::testing::Test,
-      public ::testing::WithParamInterface<std::string> {
+class BandwidthQualityScalerTest : public ::testing::Test {
  protected:
   enum ScaleDirection {
     kKeepScaleNormalBandwidth,
@@ -94,13 +81,13 @@
   };
 
   BandwidthQualityScalerTest()
-      : scoped_field_trial_(GetParam()),
-        task_queue_("BandwidthQualityScalerTestQueue"),
+      : task_queue_(time_controller_.GetTaskQueueFactory()->CreateTaskQueue(
+            "BandwidthQualityScalerTestQueue",
+            TaskQueueFactory::Priority::NORMAL)),
         handler_(std::make_unique<FakeBandwidthQualityScalerHandler>()) {
     task_queue_.SendTask([this] {
       bandwidth_quality_scaler_ =
-          std::unique_ptr<BandwidthQualityScalerUnderTest>(
-              new BandwidthQualityScalerUnderTest(handler_.get()));
+          std::make_unique<BandwidthQualityScaler>(handler_.get());
       bandwidth_quality_scaler_->SetResolutionBitrateLimits(
           EncoderInfoSettings::
               GetDefaultSinglecastBitrateLimitsWhenQpIsUntrusted());
@@ -149,52 +136,51 @@
 
   void TriggerBandwidthQualityScalerTest(
       const std::vector<FrameConfig>& frame_configs) {
-    task_queue_.SendTask([frame_configs, this] {
-      RTC_CHECK(!frame_configs.empty());
+    RTC_CHECK(!frame_configs.empty());
 
-      int total_frame_nums = 0;
-      for (const FrameConfig& frame_config : frame_configs) {
-        total_frame_nums += frame_config.frame_num;
+    int total_frame_nums = 0;
+    for (const FrameConfig& frame_config : frame_configs) {
+      total_frame_nums += frame_config.frame_num;
+    }
+
+    EXPECT_EQ(kFramerateFps *
+                  BandwidthQualityScaler::kBitrateStateUpdateInterval.seconds(),
+              total_frame_nums);
+
+    TimeDelta delay = TimeDelta::Zero();
+    int num_delayed_tasks = 0;
+    for (const FrameConfig& config : frame_configs) {
+      absl::optional<VideoEncoder::ResolutionBitrateLimits> suitable_bitrate =
+          GetDefaultSuitableBitrateLimit(config.actual_width *
+                                         config.actual_height);
+      EXPECT_TRUE(suitable_bitrate);
+      for (int j = 0; j <= config.frame_num; ++j) {
+        delay += kDefaultEncodeTime;
+        int frame_size_bytes = GetFrameSizeBytes(config, *suitable_bitrate);
+        RTC_CHECK_GT(frame_size_bytes, 0);
+        ++num_delayed_tasks;
+        task_queue_.PostDelayedTask(
+            [frame_size_bytes, config, &num_delayed_tasks, this] {
+              bandwidth_quality_scaler_->ReportEncodeInfo(
+                  frame_size_bytes,
+                  time_controller_.GetClock()->CurrentTime().ms(),
+                  config.actual_width, config.actual_height);
+              --num_delayed_tasks;
+            },
+            delay);
       }
-
-      EXPECT_EQ(kFramerateFps * kDefaultBitrateStateUpdateInterval.seconds(),
-                total_frame_nums);
-
-      uint32_t time_send_to_scaler_ms_ = rtc::TimeMillis();
-      for (size_t i = 0; i < frame_configs.size(); ++i) {
-        const FrameConfig& config = frame_configs[i];
-        absl::optional<VideoEncoder::ResolutionBitrateLimits> suitable_bitrate =
-            GetDefaultSuitableBitrateLimit(config.actual_width *
-                                           config.actual_height);
-        EXPECT_TRUE(suitable_bitrate);
-        for (int j = 0; j <= config.frame_num; ++j) {
-          time_send_to_scaler_ms_ += kDefaultEncodeTime.ms();
-          int frame_size_bytes =
-              GetFrameSizeBytes(config, suitable_bitrate.value());
-          RTC_CHECK(frame_size_bytes > 0);
-          bandwidth_quality_scaler_->ReportEncodeInfo(
-              frame_size_bytes, time_send_to_scaler_ms_, config.actual_width,
-              config.actual_height);
-        }
-      }
-    });
+    }
+    time_controller_.AdvanceTime(delay);
+    ASSERT_TRUE(time_controller_.Wait([&] { return num_delayed_tasks == 0; }));
   }
 
-  test::ScopedFieldTrials scoped_field_trial_;
+  GlobalSimulatedTimeController time_controller_{Timestamp::Seconds(1234)};
   TaskQueueForTest task_queue_;
-  std::unique_ptr<BandwidthQualityScalerUnderTest> bandwidth_quality_scaler_;
+  std::unique_ptr<BandwidthQualityScaler> bandwidth_quality_scaler_;
   std::unique_ptr<FakeBandwidthQualityScalerHandler> handler_;
 };
 
-INSTANTIATE_TEST_SUITE_P(
-    FieldTrials,
-    BandwidthQualityScalerTest,
-    ::testing::Values("WebRTC-Video-BandwidthQualityScalerSettings/"
-                      "bitrate_state_update_interval_s_:1/",
-                      "WebRTC-Video-BandwidthQualityScalerSettings/"
-                      "bitrate_state_update_interval_s_:2/"));
-
-TEST_P(BandwidthQualityScalerTest, AllNormalFrame_640x360) {
+TEST_F(BandwidthQualityScalerTest, AllNormalFrame_640x360) {
   const std::vector<FrameConfig> frame_configs{
       FrameConfig(150, FrameType::kNormalFrame, 640, 360)};
   TriggerBandwidthQualityScalerTest(frame_configs);
@@ -202,13 +188,12 @@
   // When resolution is 640*360, experimental working bitrate range is
   // [500000,800000] bps. Encoded bitrate is 654253, so it falls in the range
   // without any operation(up/down).
-  EXPECT_FALSE(handler_->event_.Wait(TimeDelta::Millis(
-      bandwidth_quality_scaler_->GetBitrateStateUpdateIntervalMs())));
+  EXPECT_FALSE(handler_->event_.Wait(kWaitTime));
   EXPECT_EQ(0, handler_->adapt_down_event_count_);
   EXPECT_EQ(0, handler_->adapt_up_event_count_);
 }
 
-TEST_P(BandwidthQualityScalerTest, AllNoramlFrame_AboveMaxBandwidth_640x360) {
+TEST_F(BandwidthQualityScalerTest, AllNormalFrame_AboveMaxBandwidth_640x360) {
   const std::vector<FrameConfig> frame_configs{
       FrameConfig(150, FrameType::kNormalFrame_Overuse, 640, 360)};
   TriggerBandwidthQualityScalerTest(frame_configs);
@@ -216,13 +201,12 @@
   // When resolution is 640*360, experimental working bitrate range is
   // [500000,800000] bps. Encoded bitrate is 1208000 > 800000 * 0.95, so it
   // triggers adapt_up_event_count_.
-  EXPECT_TRUE(handler_->event_.Wait(TimeDelta::Millis(
-      bandwidth_quality_scaler_->GetBitrateStateUpdateIntervalMs())));
+  EXPECT_TRUE(handler_->event_.Wait(kWaitTime));
   EXPECT_EQ(0, handler_->adapt_down_event_count_);
   EXPECT_EQ(1, handler_->adapt_up_event_count_);
 }
 
-TEST_P(BandwidthQualityScalerTest, AllNormalFrame_Underuse_640x360) {
+TEST_F(BandwidthQualityScalerTest, AllNormalFrame_Underuse_640x360) {
   const std::vector<FrameConfig> frame_configs{
       FrameConfig(150, FrameType::kNormalFrame_Underuse, 640, 360)};
   TriggerBandwidthQualityScalerTest(frame_configs);
@@ -230,13 +214,12 @@
   // When resolution is 640*360, experimental working bitrate range is
   // [500000,800000] bps. Encoded bitrate is 377379 < 500000 * 0.8, so it
   // triggers adapt_down_event_count_.
-  EXPECT_TRUE(handler_->event_.Wait(TimeDelta::Millis(
-      bandwidth_quality_scaler_->GetBitrateStateUpdateIntervalMs())));
+  EXPECT_TRUE(handler_->event_.Wait(kWaitTime));
   EXPECT_EQ(1, handler_->adapt_down_event_count_);
   EXPECT_EQ(0, handler_->adapt_up_event_count_);
 }
 
-TEST_P(BandwidthQualityScalerTest, FixedFrameTypeTest1_640x360) {
+TEST_F(BandwidthQualityScalerTest, FixedFrameTypeTest1_640x360) {
   const std::vector<FrameConfig> frame_configs{
       FrameConfig(5, FrameType::kNormalFrame_Underuse, 640, 360),
       FrameConfig(110, FrameType::kNormalFrame, 640, 360),
@@ -248,13 +231,12 @@
   // When resolution is 640*360, experimental working bitrate range is
   // [500000,800000] bps. Encoded bitrate is 1059462 > 800000 * 0.95, so it
   // triggers adapt_up_event_count_.
-  EXPECT_TRUE(handler_->event_.Wait(TimeDelta::Millis(
-      bandwidth_quality_scaler_->GetBitrateStateUpdateIntervalMs())));
+  EXPECT_TRUE(handler_->event_.Wait(kWaitTime));
   EXPECT_EQ(0, handler_->adapt_down_event_count_);
   EXPECT_EQ(1, handler_->adapt_up_event_count_);
 }
 
-TEST_P(BandwidthQualityScalerTest, FixedFrameTypeTest2_640x360) {
+TEST_F(BandwidthQualityScalerTest, FixedFrameTypeTest2_640x360) {
   const std::vector<FrameConfig> frame_configs{
       FrameConfig(10, FrameType::kNormalFrame_Underuse, 640, 360),
       FrameConfig(50, FrameType::kNormalFrame, 640, 360),
@@ -266,8 +248,7 @@
   // When resolution is 640*360, experimental working bitrate range is
   // [500000,800000] bps. Encoded bitrate is 1059462 > 800000 * 0.95, so it
   // triggers adapt_up_event_count_.
-  EXPECT_TRUE(handler_->event_.Wait(TimeDelta::Millis(
-      bandwidth_quality_scaler_->GetBitrateStateUpdateIntervalMs())));
+  EXPECT_TRUE(handler_->event_.Wait(kWaitTime));
   EXPECT_EQ(0, handler_->adapt_down_event_count_);
   EXPECT_EQ(1, handler_->adapt_up_event_count_);
 }
diff --git a/rtc_base/experiments/BUILD.gn b/rtc_base/experiments/BUILD.gn
index a8cd9c5..0e4f8ae 100644
--- a/rtc_base/experiments/BUILD.gn
+++ b/rtc_base/experiments/BUILD.gn
@@ -78,21 +78,6 @@
   absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
 }
 
-rtc_library("bandwidth_quality_scaler_settings") {
-  sources = [
-    "bandwidth_quality_scaler_settings.cc",
-    "bandwidth_quality_scaler_settings.h",
-  ]
-  deps = [
-    ":field_trial_parser",
-    "..:logging",
-    "../../api:field_trials_view",
-    "../../api/transport:field_trial_based_config",
-    "../../system_wrappers:field_trial",
-  ]
-  absl_deps = [ "//third_party/abseil-cpp/absl/types:optional" ]
-}
-
 rtc_library("quality_scaling_experiment") {
   sources = [
     "quality_scaling_experiment.cc",
@@ -224,7 +209,6 @@
 
     sources = [
       "balanced_degradation_settings_unittest.cc",
-      "bandwidth_quality_scaler_settings_unittest.cc",
       "encoder_info_settings_unittest.cc",
       "field_trial_list_unittest.cc",
       "field_trial_parser_unittest.cc",
@@ -241,7 +225,6 @@
     ]
     deps = [
       ":balanced_degradation_settings",
-      ":bandwidth_quality_scaler_settings",
       ":encoder_info_settings",
       ":field_trial_parser",
       ":keyframe_interval_settings_experiment",
diff --git a/rtc_base/experiments/bandwidth_quality_scaler_settings.cc b/rtc_base/experiments/bandwidth_quality_scaler_settings.cc
deleted file mode 100644
index 0a9df49..0000000
--- a/rtc_base/experiments/bandwidth_quality_scaler_settings.cc
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- *  Copyright (c) 2021 The WebRTC project authors. All Rights Reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS.  All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#include "rtc_base/experiments/bandwidth_quality_scaler_settings.h"
-
-#include "api/transport/field_trial_based_config.h"
-#include "rtc_base/logging.h"
-
-namespace webrtc {
-
-BandwidthQualityScalerSettings::BandwidthQualityScalerSettings(
-    const FieldTrialsView* const key_value_config)
-    : bitrate_state_update_interval_s_("bitrate_state_update_interval_s_") {
-  ParseFieldTrial(
-      {&bitrate_state_update_interval_s_},
-      key_value_config->Lookup("WebRTC-Video-BandwidthQualityScalerSettings"));
-}
-
-BandwidthQualityScalerSettings
-BandwidthQualityScalerSettings::ParseFromFieldTrials() {
-  FieldTrialBasedConfig field_trial_config;
-  return BandwidthQualityScalerSettings(&field_trial_config);
-}
-
-absl::optional<uint32_t>
-BandwidthQualityScalerSettings::BitrateStateUpdateInterval() const {
-  if (bitrate_state_update_interval_s_ &&
-      bitrate_state_update_interval_s_.Value() <= 0) {
-    RTC_LOG(LS_WARNING)
-        << "Unsupported bitrate_state_update_interval_s_ value, ignored.";
-    return absl::nullopt;
-  }
-  return bitrate_state_update_interval_s_.GetOptional();
-}
-
-}  // namespace webrtc
diff --git a/rtc_base/experiments/bandwidth_quality_scaler_settings.h b/rtc_base/experiments/bandwidth_quality_scaler_settings.h
deleted file mode 100644
index 21e115d..0000000
--- a/rtc_base/experiments/bandwidth_quality_scaler_settings.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- *  Copyright (c) 2021 The WebRTC project authors. All Rights Reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS.  All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#ifndef RTC_BASE_EXPERIMENTS_BANDWIDTH_QUALITY_SCALER_SETTINGS_H_
-#define RTC_BASE_EXPERIMENTS_BANDWIDTH_QUALITY_SCALER_SETTINGS_H_
-
-#include "absl/types/optional.h"
-#include "api/field_trials_view.h"
-#include "rtc_base/experiments/field_trial_parser.h"
-
-namespace webrtc {
-
-class BandwidthQualityScalerSettings final {
- public:
-  static BandwidthQualityScalerSettings ParseFromFieldTrials();
-
-  absl::optional<uint32_t> BitrateStateUpdateInterval() const;
-
- private:
-  explicit BandwidthQualityScalerSettings(
-      const FieldTrialsView* const key_value_config);
-
-  FieldTrialOptional<uint32_t> bitrate_state_update_interval_s_;
-};
-
-}  // namespace webrtc
-
-#endif  // RTC_BASE_EXPERIMENTS_BANDWIDTH_QUALITY_SCALER_SETTINGS_H_
diff --git a/rtc_base/experiments/bandwidth_quality_scaler_settings_unittest.cc b/rtc_base/experiments/bandwidth_quality_scaler_settings_unittest.cc
deleted file mode 100644
index fab22ce..0000000
--- a/rtc_base/experiments/bandwidth_quality_scaler_settings_unittest.cc
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- *  Copyright 2021 The WebRTC project authors. All Rights Reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS.  All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#include "rtc_base/experiments/bandwidth_quality_scaler_settings.h"
-
-#include "test/field_trial.h"
-#include "test/gtest.h"
-
-namespace webrtc {
-namespace {
-
-TEST(BandwidthQualityScalerSettingsTest, ValuesNotSetByDefault) {
-  const auto settings = BandwidthQualityScalerSettings::ParseFromFieldTrials();
-  EXPECT_FALSE(settings.BitrateStateUpdateInterval());
-}
-
-TEST(BandwidthQualityScalerSettingsTest, ParseBitrateStateUpdateInterval) {
-  test::ScopedFieldTrials field_trials(
-      "WebRTC-Video-BandwidthQualityScalerSettings/"
-      "bitrate_state_update_interval_s_:100/");
-  EXPECT_EQ(100u, BandwidthQualityScalerSettings::ParseFromFieldTrials()
-                      .BitrateStateUpdateInterval());
-}
-
-TEST(BandwidthQualityScalerSettingsTest, ParseAll) {
-  test::ScopedFieldTrials field_trials(
-      "WebRTC-Video-BandwidthQualityScalerSettings/"
-      "bitrate_state_update_interval_s_:100/");
-  EXPECT_EQ(100u, BandwidthQualityScalerSettings::ParseFromFieldTrials()
-                      .BitrateStateUpdateInterval());
-}
-
-TEST(BandwidthQualityScalerSettingsTest, DoesNotParseIncorrectValue) {
-  test::ScopedFieldTrials field_trials(
-      "WebRTC-Video-BandwidthQualityScalerSettings/"
-      "bitrate_state_update_interval_s_:??/");
-  const auto settings = BandwidthQualityScalerSettings::ParseFromFieldTrials();
-  EXPECT_FALSE(settings.BitrateStateUpdateInterval());
-}
-
-}  // namespace
-}  // namespace webrtc