diff --git a/video/BUILD.gn b/video/BUILD.gn
index 65f02d8..6e59619 100644
--- a/video/BUILD.gn
+++ b/video/BUILD.gn
@@ -280,6 +280,7 @@
     "../rtc_base:logging",
     "../rtc_base:macromagic",
     "../rtc_base:rtc_task_queue",
+    "../rtc_base/experiments:rtt_mult_experiment",
     "../system_wrappers",
     "../system_wrappers:field_trial",
   ]
diff --git a/video/frame_buffer_proxy.cc b/video/frame_buffer_proxy.cc
index 5bf2e22..1d28d94 100644
--- a/video/frame_buffer_proxy.cc
+++ b/video/frame_buffer_proxy.cc
@@ -21,11 +21,11 @@
 #include "api/video/encoded_frame.h"
 #include "api/video/frame_buffer.h"
 #include "api/video/video_content_type.h"
-#include "modules/video_coding/frame_buffer2.h"
 #include "modules/video_coding/frame_helpers.h"
 #include "modules/video_coding/timing/inter_frame_delay.h"
 #include "modules/video_coding/timing/jitter_estimator.h"
 #include "rtc_base/checks.h"
+#include "rtc_base/experiments/rtt_mult_experiment.h"
 #include "rtc_base/logging.h"
 #include "rtc_base/thread_annotations.h"
 #include "video/frame_decode_timing.h"
@@ -36,104 +36,6 @@
 
 namespace {
 
-class FrameBuffer2Proxy : public FrameBufferProxy {
- public:
-  FrameBuffer2Proxy(Clock* clock,
-                    VCMTiming* timing,
-                    VCMReceiveStatisticsCallback* stats_proxy,
-                    rtc::TaskQueue* decode_queue,
-                    FrameSchedulingReceiver* receiver,
-                    TimeDelta max_wait_for_keyframe,
-                    TimeDelta max_wait_for_frame,
-                    const FieldTrialsView& field_trials)
-      : max_wait_for_keyframe_(max_wait_for_keyframe),
-        max_wait_for_frame_(max_wait_for_frame),
-        frame_buffer_(clock, timing, stats_proxy, field_trials),
-        decode_queue_(decode_queue),
-        stats_proxy_(stats_proxy),
-        receiver_(receiver) {
-    RTC_DCHECK(decode_queue_);
-    RTC_DCHECK(stats_proxy_);
-    RTC_DCHECK(receiver_);
-  }
-
-  void StopOnWorker() override {
-    RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
-    decode_queue_->PostTask([this] {
-      frame_buffer_.Stop();
-      decode_safety_->SetNotAlive();
-    });
-  }
-
-  void SetProtectionMode(VCMVideoProtection protection_mode) override {
-    RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
-    frame_buffer_.SetProtectionMode(kProtectionNackFEC);
-  }
-
-  void Clear() override {
-    RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
-    frame_buffer_.Clear();
-  }
-
-  absl::optional<int64_t> InsertFrame(
-      std::unique_ptr<EncodedFrame> frame) override {
-    RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
-    int64_t last_continuous_pid = frame_buffer_.InsertFrame(std::move(frame));
-    if (last_continuous_pid != -1)
-      return last_continuous_pid;
-    return absl::nullopt;
-  }
-
-  void UpdateRtt(int64_t max_rtt_ms) override {
-    RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
-    frame_buffer_.UpdateRtt(max_rtt_ms);
-  }
-
-  void StartNextDecode(bool keyframe_required) override {
-    if (!decode_queue_->IsCurrent()) {
-      decode_queue_->PostTask(ToQueuedTask(
-          decode_safety_,
-          [this, keyframe_required] { StartNextDecode(keyframe_required); }));
-      return;
-    }
-    RTC_DCHECK_RUN_ON(decode_queue_);
-
-    frame_buffer_.NextFrame(
-        MaxWait(keyframe_required).ms(), keyframe_required, decode_queue_,
-        /* encoded frame handler */
-        [this, keyframe_required](std::unique_ptr<EncodedFrame> frame) {
-          RTC_DCHECK_RUN_ON(decode_queue_);
-          if (!decode_safety_->alive())
-            return;
-          if (frame) {
-            receiver_->OnEncodedFrame(std::move(frame));
-          } else {
-            receiver_->OnDecodableFrameTimeout(MaxWait(keyframe_required));
-          }
-        });
-  }
-
-  int Size() override {
-    RTC_DCHECK_RUN_ON(&worker_sequence_checker_);
-    return frame_buffer_.Size();
-  }
-
- private:
-  TimeDelta MaxWait(bool keyframe_required) const {
-    return keyframe_required ? max_wait_for_keyframe_ : max_wait_for_frame_;
-  }
-
-  RTC_NO_UNIQUE_ADDRESS SequenceChecker worker_sequence_checker_;
-  const TimeDelta max_wait_for_keyframe_;
-  const TimeDelta max_wait_for_frame_;
-  video_coding::FrameBuffer frame_buffer_;
-  rtc::TaskQueue* const decode_queue_;
-  VCMReceiveStatisticsCallback* const stats_proxy_;
-  FrameSchedulingReceiver* const receiver_;
-  rtc::scoped_refptr<PendingTaskSafetyFlag> decode_safety_ =
-      PendingTaskSafetyFlag::CreateDetached();
-};
-
 // Max number of frames the buffer will hold.
 static constexpr size_t kMaxFramesBuffered = 800;
 // Max number of decoded frame info that will be saved.
@@ -534,7 +436,6 @@
 };
 
 enum class FrameBufferArm {
-  kFrameBuffer2,
   kFrameBuffer3,
   kSyncDecode,
 };
@@ -545,7 +446,6 @@
   webrtc::FieldTrialEnum<FrameBufferArm> arm(
       "arm", FrameBufferArm::kFrameBuffer3,
       {
-          {"FrameBuffer2", FrameBufferArm::kFrameBuffer2},
           {"FrameBuffer3", FrameBufferArm::kFrameBuffer3},
           {"SyncDecoding", FrameBufferArm::kSyncDecode},
       });
@@ -567,10 +467,6 @@
     DecodeSynchronizer* decode_sync,
     const FieldTrialsView& field_trials) {
   switch (ParseFrameBufferFieldTrial(field_trials)) {
-    case FrameBufferArm::kFrameBuffer2:
-      return std::make_unique<FrameBuffer2Proxy>(
-          clock, timing, stats_proxy, decode_queue, receiver,
-          max_wait_for_keyframe, max_wait_for_frame, field_trials);
     case FrameBufferArm::kSyncDecode: {
       std::unique_ptr<FrameDecodeScheduler> scheduler;
       if (decode_sync) {
diff --git a/video/frame_buffer_proxy_unittest.cc b/video/frame_buffer_proxy_unittest.cc
index 6babcda..4d4aae4 100644
--- a/video/frame_buffer_proxy_unittest.cc
+++ b/video/frame_buffer_proxy_unittest.cc
@@ -27,7 +27,6 @@
 #include "api/video/video_content_type.h"
 #include "api/video/video_timing.h"
 #include "rtc_base/checks.h"
-#include "rtc_base/event.h"
 #include "test/fake_encoded_frame.h"
 #include "test/gmock.h"
 #include "test/gtest.h"
@@ -104,11 +103,6 @@
               (override));
 };
 
-bool IsFrameBuffer2Enabled(const FieldTrialsView& field_trials) {
-  return field_trials.Lookup("WebRTC-FrameBuffer3").find("arm:FrameBuffer2") !=
-         std::string::npos;
-}
-
 }  // namespace
 
 constexpr auto kMaxWaitForKeyframe = TimeDelta::Millis(500);
@@ -239,7 +233,7 @@
 
 TEST_P(FrameBufferProxyTest, InitialTimeoutAfterKeyframeTimeoutPeriod) {
   StartNextDecodeForceKeyframe();
-  // No frame insterted. Timeout expected.
+  // No frame inserted. Timeout expected.
   EXPECT_THAT(WaitForFrameOrTimeout(kMaxWaitForKeyframe), TimedOut());
 
   // No new timeout set since receiver has not started new decode.
@@ -664,8 +658,6 @@
 
 TEST_P(FrameBufferProxyTest, FrameCompleteCalledOnceForCompleteTemporalUnit) {
   // FrameBuffer2 logs the complete frame on the arrival of the last layer.
-  if (IsFrameBuffer2Enabled(field_trials_))
-    return;
   StartNextDecodeForceKeyframe();
 
   // `OnCompleteFrame` should not be called for the first two frames since they
@@ -742,18 +734,13 @@
                           .AsLast()
                           .Build());
   // FrameBuffer2 drops the frame, while FrameBuffer3 will continue the stream.
-  if (!IsFrameBuffer2Enabled(field_trials_)) {
-    EXPECT_THAT(WaitForFrameOrTimeout(kFps30Delay), Frame(test::WithId(2)));
-  } else {
-    EXPECT_THAT(WaitForFrameOrTimeout(kMaxWaitForFrame), TimedOut());
-  }
+  EXPECT_THAT(WaitForFrameOrTimeout(kFps30Delay), Frame(test::WithId(2)));
 }
 
 INSTANTIATE_TEST_SUITE_P(
     FrameBufferProxy,
     FrameBufferProxyTest,
-    ::testing::Values("WebRTC-FrameBuffer3/arm:FrameBuffer2/",
-                      "WebRTC-FrameBuffer3/arm:FrameBuffer3/",
+    ::testing::Values("WebRTC-FrameBuffer3/arm:FrameBuffer3/",
                       "WebRTC-FrameBuffer3/arm:SyncDecoding/"));
 
 class LowLatencyFrameBufferProxyTest : public ::testing::Test,
@@ -834,8 +821,6 @@
     FrameBufferProxy,
     LowLatencyFrameBufferProxyTest,
     ::testing::Values(
-        "WebRTC-FrameBuffer3/arm:FrameBuffer2/"
-        "WebRTC-ZeroPlayoutDelay/min_pacing:16ms,max_decode_queue_size:5/",
         "WebRTC-FrameBuffer3/arm:FrameBuffer3/"
         "WebRTC-ZeroPlayoutDelay/min_pacing:16ms,max_decode_queue_size:5/",
         "WebRTC-FrameBuffer3/arm:SyncDecoding/"