diff --git a/sycl/include/sycl/ext/oneapi/experimental/enqueue_functions.hpp b/sycl/include/sycl/ext/oneapi/experimental/enqueue_functions.hpp
index dba38b72ca769..1234fc36213b2 100644
--- a/sycl/include/sycl/ext/oneapi/experimental/enqueue_functions.hpp
+++ b/sycl/include/sycl/ext/oneapi/experimental/enqueue_functions.hpp
@@ -108,7 +108,7 @@ event submit_with_event_impl(queue &Q, PropertiesT Props,
                              CommandGroupFunc &&CGF,
                              const sycl::detail::code_location &CodeLoc) {
   return Q.submit_with_event<__SYCL_USE_FALLBACK_ASSERT>(
-      Props, detail::type_erased_cgfo_ty{CGF}, nullptr, CodeLoc);
+      Props, detail::type_erased_cgfo_ty{CGF}, CodeLoc);
 }
 } // namespace detail
 
diff --git a/sycl/include/sycl/handler.hpp b/sycl/include/sycl/handler.hpp
index 52bf35c9c2809..a1751abfb5204 100644
--- a/sycl/include/sycl/handler.hpp
+++ b/sycl/include/sycl/handler.hpp
@@ -434,7 +434,6 @@ class __SYCL_EXPORT handler {
   handler(std::shared_ptr<detail::queue_impl> Queue, bool CallerNeedsEvent);
 #endif
 
-#ifdef __INTEL_PREVIEW_BREAKING_CHANGES
   /// Constructs SYCL handler from the pre-constructed handler_impl and the
   /// associated queue. Inside of Graph implementation, the Queue value is not
   /// used, for those cases it can be initialized with an empty shared_ptr.
@@ -443,7 +442,8 @@ class __SYCL_EXPORT handler {
   /// \param Queue is a SYCL queue.
   handler(detail::handler_impl *HandlerImpl,
           const std::shared_ptr<detail::queue_impl> &Queue);
-#else
+
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
   /// Constructs SYCL handler from the associated queue and the submission's
   /// primary and secondary queue.
   ///
@@ -454,20 +454,16 @@ class __SYCL_EXPORT handler {
   ///        is null if no secondary queue is associated with the submission.
   /// \param CallerNeedsEvent indicates if the event resulting from this handler
   ///        is needed by the caller.
-#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
   // TODO: This function is not used anymore, remove it in the next
   // ABI-breaking window.
   handler(std::shared_ptr<detail::queue_impl> Queue,
           std::shared_ptr<detail::queue_impl> PrimaryQueue,
           std::shared_ptr<detail::queue_impl> SecondaryQueue,
           bool CallerNeedsEvent);
-#endif
   __SYCL_DLL_LOCAL handler(std::shared_ptr<detail::queue_impl> Queue,
                            detail::queue_impl *SecondaryQueue,
                            bool CallerNeedsEvent);
-#endif
 
-#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
   /// Constructs SYCL handler from Graph.
   ///
   /// The handler will add the command-group as a node to the graph rather than
diff --git a/sycl/include/sycl/queue.hpp b/sycl/include/sycl/queue.hpp
index c9f7060cd5251..0a5c17838f0f7 100644
--- a/sycl/include/sycl/queue.hpp
+++ b/sycl/include/sycl/queue.hpp
@@ -66,7 +66,7 @@ auto get_native(const SyclObjectT &Obj)
 namespace detail {
 class queue_impl;
 
-inline event submitAssertCapture(queue &, event &, queue *,
+inline event submitAssertCapture(queue &, event &,
                                  const detail::code_location &);
 
 // Function to postprocess submitted command
@@ -87,8 +87,10 @@ class __SYCL_EXPORT SubmissionInfo {
   sycl::detail::optional<SubmitPostProcessF> &PostProcessorFunc();
   const sycl::detail::optional<SubmitPostProcessF> &PostProcessorFunc() const;
 
+#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
   std::shared_ptr<detail::queue_impl> &SecondaryQueue();
   const std::shared_ptr<detail::queue_impl> &SecondaryQueue() const;
+#endif
 
   ext::oneapi::experimental::event_mode_enum &EventMode();
   const ext::oneapi::experimental::event_mode_enum &EventMode() const;
@@ -438,17 +440,16 @@ class __SYCL_EXPORT queue : public detail::OwnerLessBase<queue> {
   /// for execution on a secondary queue.
   ///
   /// \param CGF is a function object containing command group.
-  /// \param SecondaryQueue is a fallback SYCL queue.
   /// \param CodeLoc is the code location of the submit call (default argument)
   /// \return a SYCL event object, which corresponds to the queue the command
   /// group is being enqueued on.
   template <typename T>
   std::enable_if_t<std::is_invocable_r_v<void, T, handler &>, event> submit(
-      T CGF, queue &SecondaryQueue,
+      T CGF, queue &,
       const detail::code_location &CodeLoc = detail::code_location::current()) {
     return submit_with_event<__SYCL_USE_FALLBACK_ASSERT>(
         sycl::ext::oneapi::experimental::empty_properties_t{},
-        detail::type_erased_cgfo_ty{CGF}, &SecondaryQueue, CodeLoc);
+        detail::type_erased_cgfo_ty{CGF}, CodeLoc);
   }
 
   /// Prevents any commands submitted afterward to this queue from executing
@@ -3582,7 +3583,7 @@ class __SYCL_EXPORT queue : public detail::OwnerLessBase<queue> {
       -> backend_return_t<BackendName, SyclObjectT>;
 
 #if __SYCL_USE_FALLBACK_ASSERT
-  friend event detail::submitAssertCapture(queue &, event &, queue *,
+  friend event detail::submitAssertCapture(queue &, event &,
                                            const detail::code_location &);
 #endif
 
@@ -3675,46 +3676,6 @@ class __SYCL_EXPORT queue : public detail::OwnerLessBase<queue> {
                                  const detail::code_location &CodeLoc,
                                  bool IsTopCodeLoc);
 
-  /// Submits a command group function object to the queue, in order to be
-  /// scheduled for execution on the device.
-  ///
-  /// \param Props is a property list with submission properties.
-  /// \param CGF is a function object containing command group.
-  /// \param SecondaryQueuePtr is a pointer to the secondary queue.
-  /// \param CodeLoc is the code location of the submit call (default argument)
-  /// \return a SYCL event object for the submitted command group.
-  //
-  // UseFallBackAssert as template param vs `#if` in function body is necessary
-  // to prevent ODR-violation between TUs built with different fallback assert
-  // modes.
-  template <bool UseFallbackAssert, typename PropertiesT>
-  event submit_with_event(
-      PropertiesT Props, const detail::type_erased_cgfo_ty &CGF,
-      queue *SecondaryQueuePtr,
-      const detail::code_location &CodeLoc = detail::code_location::current()) {
-    detail::tls_code_loc_t TlsCodeLocCapture(CodeLoc);
-    detail::v1::SubmissionInfo SI{};
-    ProcessSubmitProperties(Props, SI);
-    if (SecondaryQueuePtr)
-      SI.SecondaryQueue() = detail::getSyclObjImpl(*SecondaryQueuePtr);
-    if constexpr (UseFallbackAssert)
-      SI.PostProcessorFunc() =
-          [this, &SecondaryQueuePtr,
-           &TlsCodeLocCapture](bool IsKernel, bool KernelUsesAssert, event &E) {
-            if (IsKernel && !device_has(aspect::ext_oneapi_native_assert) &&
-                KernelUsesAssert && !device_has(aspect::accelerator)) {
-              // __devicelib_assert_fail isn't supported by Device-side Runtime
-              // Linking against fallback impl of __devicelib_assert_fail is
-              // performed by program manager class
-              // Fallback assert isn't supported for FPGA
-              submitAssertCapture(*this, E, SecondaryQueuePtr,
-                                  TlsCodeLocCapture.query());
-            }
-          };
-    return submit_with_event_impl(CGF, SI, TlsCodeLocCapture.query(),
-                                  TlsCodeLocCapture.isToplevel());
-  }
-
   /// Submits a command group function object to the queue, in order to be
   /// scheduled for execution on the device.
   ///
@@ -3743,7 +3704,7 @@ class __SYCL_EXPORT queue : public detail::OwnerLessBase<queue> {
           // Linking against fallback impl of __devicelib_assert_fail is
           // performed by program manager class
           // Fallback assert isn't supported for FPGA
-          submitAssertCapture(*this, E, nullptr, TlsCodeLocCapture.query());
+          submitAssertCapture(*this, E, TlsCodeLocCapture.query());
         }
       };
     return submit_with_event_impl(CGF, SI, TlsCodeLocCapture.query(),
@@ -3942,14 +3903,13 @@ class AssertInfoCopier;
  * Submit copy task for assert failure flag and host-task to check the flag
  * \param Event kernel's event to depend on i.e. the event represents the
  *              kernel to check for assertion failure
- * \param SecondaryQueue secondary queue for submit process, null if not used
  * \returns host tasks event
  *
  * This method doesn't belong to queue class to overcome msvc behaviour due to
  * which it gets compiled and exported without any integration header and, thus,
  * with no proper KernelInfo instance.
  */
-event submitAssertCapture(queue &Self, event &Event, queue *SecondaryQueue,
+event submitAssertCapture(queue &Self, event &Event,
                           const detail::code_location &CodeLoc) {
   buffer<detail::AssertHappened, 1> Buffer{1};
 
@@ -4005,10 +3965,10 @@ event submitAssertCapture(queue &Self, event &Event, queue *SecondaryQueue,
 
   CopierEv = Self.submit_with_event<true>(
       sycl::ext::oneapi::experimental::empty_properties_t{}, CopierCGF,
-      SecondaryQueue, CodeLoc);
+      CodeLoc);
   CheckerEv = Self.submit_with_event<true>(
       sycl::ext::oneapi::experimental::empty_properties_t{}, CheckerCGF,
-      SecondaryQueue, CodeLoc);
+      CodeLoc);
 
   return CheckerEv;
 }
diff --git a/sycl/source/detail/handler_impl.hpp b/sycl/source/detail/handler_impl.hpp
index 9dac6a7f435d4..cb6cd2014345c 100644
--- a/sycl/source/detail/handler_impl.hpp
+++ b/sycl/source/detail/handler_impl.hpp
@@ -31,9 +31,7 @@ enum class HandlerSubmissionState : std::uint8_t {
 
 class handler_impl {
 public:
-  handler_impl(queue_impl *SubmissionSecondaryQueue, bool EventNeeded)
-      : MSubmissionSecondaryQueue(SubmissionSecondaryQueue),
-        MEventNeeded(EventNeeded) {};
+  handler_impl(bool EventNeeded) : MEventNeeded(EventNeeded) {};
 
   handler_impl(
       std::shared_ptr<ext::oneapi::experimental::detail::graph_impl> Graph)
@@ -67,10 +65,6 @@ class handler_impl {
   /// Registers mutually exclusive submission states.
   HandlerSubmissionState MSubmissionState = HandlerSubmissionState::NO_STATE;
 
-  /// Pointer to the secondary queue implementation. Nullptr if no
-  /// secondary queue fallback was given in the associated submission.
-  queue_impl *MSubmissionSecondaryQueue = nullptr;
-
   /// Bool stores information about whether the event resulting from the
   /// corresponding work is required.
   bool MEventNeeded = true;
diff --git a/sycl/source/detail/queue_impl.cpp b/sycl/source/detail/queue_impl.cpp
index 1a1877e391117..632b05571ed0c 100644
--- a/sycl/source/detail/queue_impl.cpp
+++ b/sycl/source/detail/queue_impl.cpp
@@ -315,16 +315,16 @@ void queue_impl::addEvent(const event &Event) {
 
 event queue_impl::submit_impl(const detail::type_erased_cgfo_ty &CGF,
                               const std::shared_ptr<queue_impl> &Self,
-                              queue_impl *SecondaryQueue, bool CallerNeedsEvent,
+                              bool CallerNeedsEvent,
                               const detail::code_location &Loc,
                               bool IsTopCodeLoc,
                               const v1::SubmissionInfo &SubmitInfo) {
 #ifdef __INTEL_PREVIEW_BREAKING_CHANGES
-  detail::handler_impl HandlerImplVal(SecondaryQueue, CallerNeedsEvent);
+  detail::handler_impl HandlerImplVal(CallerNeedsEvent);
   detail::handler_impl *HandlerImpl = &HandlerImplVal;
   handler Handler(HandlerImpl, Self);
 #else
-  handler Handler(Self, SecondaryQueue, CallerNeedsEvent);
+  handler Handler(Self, CallerNeedsEvent);
   auto &HandlerImpl = detail::getSyclObjImpl(Handler);
 #endif
 
@@ -402,9 +402,8 @@ event queue_impl::submit_impl(const detail::type_erased_cgfo_ty &CGF,
       Stream->generateFlushCommand(ServiceCGH);
     };
     detail::type_erased_cgfo_ty CGF{L};
-    event FlushEvent =
-        submit_impl(CGF, Self, SecondaryQueue, /*CallerNeedsEvent*/ true, Loc,
-                    IsTopCodeLoc, {});
+    event FlushEvent = submit_impl(CGF, Self, /*CallerNeedsEvent*/ true, Loc,
+                                   IsTopCodeLoc, {});
     EventImpl->attachEventToCompleteWeak(detail::getSyclObjImpl(FlushEvent));
     registerStreamServiceEvent(detail::getSyclObjImpl(FlushEvent));
   }
@@ -412,20 +411,6 @@ event queue_impl::submit_impl(const detail::type_erased_cgfo_ty &CGF,
   return Event;
 }
 
-#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
-event queue_impl::submit_impl(const detail::type_erased_cgfo_ty &CGF,
-                              const std::shared_ptr<queue_impl> &Self,
-                              const std::shared_ptr<queue_impl> &,
-                              const std::shared_ptr<queue_impl> &SecondaryQueue,
-                              bool CallerNeedsEvent,
-                              const detail::code_location &Loc,
-                              bool IsTopCodeLoc,
-                              const SubmissionInfo &SubmitInfo) {
-  return submit_impl(CGF, Self, SecondaryQueue.get(), CallerNeedsEvent, Loc,
-                     IsTopCodeLoc, SubmitInfo);
-}
-#endif
-
 template <typename HandlerFuncT>
 event queue_impl::submitWithHandler(const std::shared_ptr<queue_impl> &Self,
                                     const std::vector<event> &DepEvents,
diff --git a/sycl/source/detail/queue_impl.hpp b/sycl/source/detail/queue_impl.hpp
index 7860d4ee9e123..d1ee837f5c72f 100644
--- a/sycl/source/detail/queue_impl.hpp
+++ b/sycl/source/detail/queue_impl.hpp
@@ -319,19 +319,16 @@ class queue_impl {
   ///
   /// \param CGF is a function object containing command group.
   /// \param Self is a shared_ptr to this queue.
-  /// \param SecondQueue is a shared_ptr to the secondary queue.
   /// \param Loc is the code location of the submit call (default argument)
   /// \param StoreAdditionalInfo makes additional info be stored in event_impl
   /// \return a SYCL event object, which corresponds to the queue the command
   /// group is being enqueued on.
   event submit(const detail::type_erased_cgfo_ty &CGF,
                const std::shared_ptr<queue_impl> &Self,
-               const std::shared_ptr<queue_impl> &SecondQueue,
                const detail::code_location &Loc, bool IsTopCodeLoc,
                const SubmitPostProcessF *PostProcess = nullptr) {
     event ResEvent;
     v1::SubmissionInfo SI{};
-    SI.SecondaryQueue() = SecondQueue;
     if (PostProcess)
       SI.PostProcessorFunc() = *PostProcess;
     return submit_with_event(CGF, Self, SI, Loc, IsTopCodeLoc);
@@ -350,11 +347,8 @@ class queue_impl {
                           const std::shared_ptr<queue_impl> &Self,
                           const v1::SubmissionInfo &SubmitInfo,
                           const detail::code_location &Loc, bool IsTopCodeLoc) {
-
-    event ResEvent =
-        submit_impl(CGF, Self, SubmitInfo.SecondaryQueue().get(),
-                    /*CallerNeedsEvent=*/true, Loc, IsTopCodeLoc, SubmitInfo);
-    return ResEvent;
+    return submit_impl(CGF, Self, /*CallerNeedsEvent=*/true, Loc, IsTopCodeLoc,
+                       SubmitInfo);
   }
 
   void submit_without_event(const detail::type_erased_cgfo_ty &CGF,
@@ -362,8 +356,8 @@ class queue_impl {
                             const v1::SubmissionInfo &SubmitInfo,
                             const detail::code_location &Loc,
                             bool IsTopCodeLoc) {
-    submit_impl(CGF, Self, SubmitInfo.SecondaryQueue().get(),
-                /*CallerNeedsEvent=*/false, Loc, IsTopCodeLoc, SubmitInfo);
+    submit_impl(CGF, Self, /*CallerNeedsEvent=*/false, Loc, IsTopCodeLoc,
+                SubmitInfo);
   }
 
   /// Performs a blocking wait for the completion of all enqueued tasks in the
@@ -879,15 +873,10 @@ class queue_impl {
     PostProcess(IsKernel, KernelUsesAssert, Event);
   }
 
-#ifndef __INTEL_PREVIEW_BREAKING_CHANGES
   /// Performs command group submission to the queue.
   ///
   /// \param CGF is a function object containing command group.
   /// \param Self is a pointer to this queue.
-  /// \param PrimaryQueue is a pointer to the primary queue. This may be the
-  ///        same as Self.
-  /// \param SecondaryQueue is a pointer to the secondary queue. This may be the
-  ///        same as Self.
   /// \param CallerNeedsEvent is a boolean indicating whether the event is
   ///        required by the user after the call.
   /// \param Loc is the code location of the submit call (default argument)
@@ -895,27 +884,8 @@ class queue_impl {
   /// \return a SYCL event representing submitted command group.
   event submit_impl(const detail::type_erased_cgfo_ty &CGF,
                     const std::shared_ptr<queue_impl> &Self,
-                    const std::shared_ptr<queue_impl> &PrimaryQueue,
-                    const std::shared_ptr<queue_impl> &SecondaryQueue,
                     bool CallerNeedsEvent, const detail::code_location &Loc,
-                    bool IsTopCodeLoc, const SubmissionInfo &SubmitInfo);
-#endif
-
-  /// Performs command group submission to the queue.
-  ///
-  /// \param CGF is a function object containing command group.
-  /// \param Self is a pointer to this queue.
-  /// \param SecondaryQueue is a pointer to the secondary queue.
-  /// \param CallerNeedsEvent is a boolean indicating whether the event is
-  ///        required by the user after the call.
-  /// \param Loc is the code location of the submit call (default argument)
-  /// \param SubmitInfo is additional optional information for the submission.
-  /// \return a SYCL event representing submitted command group.
-  event submit_impl(const detail::type_erased_cgfo_ty &CGF,
-                    const std::shared_ptr<queue_impl> &Self,
-                    queue_impl *SecondaryQueue, bool CallerNeedsEvent,
-                    const detail::code_location &Loc, bool IsTopCodeLoc,
-                    const v1::SubmissionInfo &SubmitInfo);
+                    bool IsTopCodeLoc, const v1::SubmissionInfo &SubmitInfo);
 
   /// Helper function for submitting a memory operation with a handler.
   /// \param Self is a shared_ptr to this queue.
diff --git a/sycl/source/detail/scheduler/scheduler.hpp b/sycl/source/detail/scheduler/scheduler.hpp
index a8f7235ac0d05..fa032dbea8f35 100644
--- a/sycl/source/detail/scheduler/scheduler.hpp
+++ b/sycl/source/detail/scheduler/scheduler.hpp
@@ -591,14 +591,6 @@ class Scheduler {
 
     void cleanupCommand(Command *Cmd, bool AllowUnsubmitted = false);
 
-    /// Reschedules the command passed using Queue provided.
-    ///
-    /// This can lead to rescheduling of all dependent commands. This can be
-    /// used when the user provides a "secondary" queue to the submit method
-    /// which may be used when the command fails to enqueue/execute in the
-    /// primary queue.
-    void rescheduleCommand(Command *Cmd, const QueueImplPtr &Queue);
-
     /// \return a pointer to the corresponding memory object record for the
     /// SYCL memory object provided, or nullptr if it does not exist.
     MemObjRecord *getMemObjRecord(SYCLMemObjI *MemObject);
diff --git a/sycl/source/handler.cpp b/sycl/source/handler.cpp
index a25107b143f6e..56892c470974c 100644
--- a/sycl/source/handler.cpp
+++ b/sycl/source/handler.cpp
@@ -316,8 +316,7 @@ fill_copy_args(detail::handler_impl *impl,
 
 handler::handler(const std::shared_ptr<detail::queue_impl> &Queue,
                  bool CallerNeedsEvent)
-    : MImplOwner(std::make_shared<detail::handler_impl>(Queue.get(),
-                                                        CallerNeedsEvent)),
+    : MImplOwner(std::make_shared<detail::handler_impl>(CallerNeedsEvent)),
       impl(MImplOwner.get()), MQueue(Queue) {}
 
 handler::handler(detail::handler_impl *HandlerImpl,
@@ -328,26 +327,23 @@ handler::handler(detail::handler_impl *HandlerImpl,
 
 handler::handler(std::shared_ptr<detail::queue_impl> Queue,
                  bool CallerNeedsEvent)
-    : impl(std::make_shared<detail::handler_impl>(nullptr, CallerNeedsEvent)),
+    : impl(std::make_shared<detail::handler_impl>(CallerNeedsEvent)),
       MQueue(std::move(Queue)) {}
 
 #ifndef __INTEL_PREVIEW_BREAKING_CHANGES
 // TODO: This function is not used anymore, remove it in the next
 // ABI-breaking window.
-handler::handler(
-    std::shared_ptr<detail::queue_impl> Queue,
-    [[maybe_unused]] std::shared_ptr<detail::queue_impl> PrimaryQueue,
-    std::shared_ptr<detail::queue_impl> SecondaryQueue, bool CallerNeedsEvent)
-    : impl(std::make_shared<detail::handler_impl>(SecondaryQueue.get(),
-                                                  CallerNeedsEvent)),
+handler::handler(std::shared_ptr<detail::queue_impl> Queue,
+                 std::shared_ptr<detail::queue_impl>,
+                 std::shared_ptr<detail::queue_impl>, bool CallerNeedsEvent)
+    : impl(std::make_shared<detail::handler_impl>(CallerNeedsEvent)),
       MQueue(Queue) {}
-#endif
 
 handler::handler(std::shared_ptr<detail::queue_impl> Queue,
-                 detail::queue_impl *SecondaryQueue, bool CallerNeedsEvent)
-    : impl(std::make_shared<detail::handler_impl>(SecondaryQueue,
-                                                  CallerNeedsEvent)),
+                 detail::queue_impl *, bool CallerNeedsEvent)
+    : impl(std::make_shared<detail::handler_impl>(CallerNeedsEvent)),
       MQueue(std::move(Queue)) {}
+#endif
 
 handler::handler(
     std::shared_ptr<ext::oneapi::experimental::detail::graph_impl> Graph)
@@ -1819,14 +1815,6 @@ void handler::use_kernel_bundle(
         "Context associated with the primary queue is different from the "
         "context associated with the kernel bundle");
 
-  if (impl->MSubmissionSecondaryQueue &&
-      impl->MSubmissionSecondaryQueue->get_context() !=
-          ExecBundle.get_context())
-    throw sycl::exception(
-        make_error_code(errc::invalid),
-        "Context associated with the secondary queue is different from the "
-        "context associated with the kernel bundle");
-
   setStateExplicitKernelBundle();
   setHandlerKernelBundle(detail::getSyclObjImpl(ExecBundle));
 }
diff --git a/sycl/source/queue.cpp b/sycl/source/queue.cpp
index bd3e02df6c84e..ff58c7b5ba562 100644
--- a/sycl/source/queue.cpp
+++ b/sycl/source/queue.cpp
@@ -210,14 +210,14 @@ event queue::submit_impl(std::function<void(handler &)> CGH,
   return submit_with_event_impl(std::move(CGH), {}, CodeLoc, IsTopCodeLoc);
 }
 
-event queue::submit_impl(std::function<void(handler &)> CGH, queue SecondQueue,
+event queue::submit_impl(std::function<void(handler &)> CGH, queue,
                          const detail::code_location &CodeLoc) {
-  return impl->submit(CGH, impl, SecondQueue.impl, CodeLoc, true);
+  return impl->submit(CGH, impl, CodeLoc, true);
 }
-event queue::submit_impl(std::function<void(handler &)> CGH, queue SecondQueue,
+event queue::submit_impl(std::function<void(handler &)> CGH, queue,
                          const detail::code_location &CodeLoc,
                          bool IsTopCodeLoc) {
-  return impl->submit(CGH, impl, SecondQueue.impl, CodeLoc, IsTopCodeLoc);
+  return impl->submit(CGH, impl, CodeLoc, IsTopCodeLoc);
 }
 
 void queue::submit_without_event_impl(std::function<void(handler &)> CGH,
@@ -246,17 +246,16 @@ event queue::submit_impl_and_postprocess(
 }
 
 event queue::submit_impl_and_postprocess(
-    std::function<void(handler &)> CGH, queue SecondQueue,
+    std::function<void(handler &)> CGH, queue,
     const detail::code_location &CodeLoc,
     const detail::SubmitPostProcessF &PostProcess) {
-  return impl->submit(CGH, impl, SecondQueue.impl, CodeLoc, true, &PostProcess);
+  return impl->submit(CGH, impl, CodeLoc, true, &PostProcess);
 }
 event queue::submit_impl_and_postprocess(
-    std::function<void(handler &)> CGH, queue SecondQueue,
+    std::function<void(handler &)> CGH, queue,
     const detail::code_location &CodeLoc,
     const detail::SubmitPostProcessF &PostProcess, bool IsTopCodeLoc) {
-  return impl->submit(CGH, impl, SecondQueue.impl, CodeLoc, IsTopCodeLoc,
-                      &PostProcess);
+  return impl->submit(CGH, impl, CodeLoc, IsTopCodeLoc, &PostProcess);
 }
 
 event queue::submit_with_event_impl(std::function<void(handler &)> CGH,
diff --git a/sycl/unittests/SYCL2020/KernelBundle.cpp b/sycl/unittests/SYCL2020/KernelBundle.cpp
index 5ffe4ecbc341a..93ae46c1b5a3b 100644
--- a/sycl/unittests/SYCL2020/KernelBundle.cpp
+++ b/sycl/unittests/SYCL2020/KernelBundle.cpp
@@ -221,188 +221,6 @@ TEST(KernelBundle, HasKernelBundle) {
   EXPECT_TRUE(HasKernelBundle);
 }
 
-TEST(KernelBundle, UseKernelBundleWrongContextPrimaryQueueOnly) {
-  sycl::unittest::UrMock<> Mock;
-
-  const sycl::device Dev = sycl::platform().get_devices()[0];
-  sycl::queue Queue{Dev};
-  const sycl::context QueueCtx = Queue.get_context();
-  const sycl::context OtherCtx{Dev};
-
-  ASSERT_NE(QueueCtx, OtherCtx);
-
-  auto KernelBundle =
-      sycl::get_kernel_bundle<sycl::bundle_state::executable>(OtherCtx, {Dev});
-
-  class UnqiueException {};
-
-  try {
-    Queue.submit([&](sycl::handler &CGH) {
-      try {
-        CGH.use_kernel_bundle(KernelBundle);
-        FAIL() << "No exception was thrown.";
-        CGH.single_task<TestKernel>([]() {});
-      } catch (const sycl::exception &e) {
-        ASSERT_EQ(e.code().value(), static_cast<int>(sycl::errc::invalid))
-            << "sycl::exception code was not the expected sycl::errc::invalid.";
-        // Throw uniquely identifiable exception to distinguish between that
-        // the sycl::exception originates from the correct level.
-        throw UnqiueException{};
-      } catch (...) {
-        FAIL()
-            << "Unexpected exception was thrown in kernel invocation function.";
-      }
-    });
-  } catch (const UnqiueException &) {
-    // Expected path
-  } catch (const sycl::exception &) {
-    FAIL() << "sycl::exception thrown at the wrong level.";
-  } catch (...) {
-    FAIL() << "Unexpected exception was thrown in submit.";
-  }
-}
-
-TEST(KernelBundle, UseKernelBundleWrongContextPrimaryQueueValidSecondaryQueue) {
-  sycl::unittest::UrMock<> Mock;
-
-  const sycl::device Dev = sycl::platform().get_devices()[0];
-  const sycl::context PrimaryCtx{Dev};
-  const sycl::context SecondaryCtx{Dev};
-
-  ASSERT_NE(PrimaryCtx, SecondaryCtx);
-
-  auto KernelBundle = sycl::get_kernel_bundle<sycl::bundle_state::executable>(
-      SecondaryCtx, {Dev});
-
-  sycl::queue PrimaryQueue{PrimaryCtx, Dev};
-  sycl::queue SecondaryQueue{SecondaryCtx, Dev};
-
-  class UnqiueException {};
-
-  try {
-    PrimaryQueue.submit(
-        [&](sycl::handler &CGH) {
-          try {
-            CGH.use_kernel_bundle(KernelBundle);
-            FAIL() << "No exception was thrown.";
-            CGH.single_task<TestKernel>([]() {});
-          } catch (const sycl::exception &e) {
-            ASSERT_EQ(e.code().value(), static_cast<int>(sycl::errc::invalid))
-                << "sycl::exception code was not the expected "
-                   "sycl::errc::invalid.";
-            // Throw uniquely identifiable exception to distinguish between that
-            // the sycl::exception originates from the correct level.
-            throw UnqiueException{};
-          } catch (...) {
-            FAIL() << "Unexpected exception was thrown in kernel invocation "
-                      "function.";
-          }
-        },
-        SecondaryQueue);
-  } catch (const UnqiueException &) {
-    // Expected path
-  } catch (const sycl::exception &) {
-    FAIL() << "sycl::exception thrown at the wrong level.";
-  } catch (...) {
-    FAIL() << "Unexpected exception was thrown in submit.";
-  }
-}
-
-TEST(KernelBundle, UseKernelBundleValidPrimaryQueueWrongContextSecondaryQueue) {
-  sycl::unittest::UrMock<> Mock;
-
-  const sycl::device Dev = sycl::platform().get_devices()[0];
-  const sycl::context PrimaryCtx{Dev};
-  const sycl::context SecondaryCtx{Dev};
-
-  ASSERT_NE(PrimaryCtx, SecondaryCtx);
-
-  auto KernelBundle = sycl::get_kernel_bundle<sycl::bundle_state::executable>(
-      PrimaryCtx, {Dev});
-
-  sycl::queue PrimaryQueue{PrimaryCtx, Dev};
-  sycl::queue SecondaryQueue{SecondaryCtx, Dev};
-
-  class UnqiueException {};
-
-  try {
-    PrimaryQueue.submit(
-        [&](sycl::handler &CGH) {
-          try {
-            CGH.use_kernel_bundle(KernelBundle);
-            FAIL() << "No exception was thrown.";
-            CGH.single_task<TestKernel>([]() {});
-          } catch (const sycl::exception &e) {
-            ASSERT_EQ(e.code().value(), static_cast<int>(sycl::errc::invalid))
-                << "sycl::exception code was not the expected "
-                   "sycl::errc::invalid.";
-            // Throw uniquely identifiable exception to distinguish between that
-            // the sycl::exception originates from the correct level.
-            throw UnqiueException{};
-          } catch (...) {
-            FAIL() << "Unexpected exception was thrown in kernel invocation "
-                      "function.";
-          }
-        },
-        SecondaryQueue);
-  } catch (const UnqiueException &) {
-    // Expected path
-  } catch (const sycl::exception &) {
-    FAIL() << "sycl::exception thrown at the wrong level.";
-  } catch (...) {
-    FAIL() << "Unexpected exception was thrown in submit.";
-  }
-}
-
-TEST(KernelBundle, UseKernelBundleWrongContextPrimaryQueueAndSecondaryQueue) {
-  sycl::unittest::UrMock<> Mock;
-
-  const sycl::device Dev = sycl::platform().get_devices()[0];
-  const sycl::context PrimaryCtx{Dev};
-  const sycl::context SecondaryCtx{Dev};
-  const sycl::context OtherCtx{Dev};
-
-  ASSERT_NE(PrimaryCtx, SecondaryCtx);
-  ASSERT_NE(PrimaryCtx, OtherCtx);
-  ASSERT_NE(SecondaryCtx, OtherCtx);
-
-  auto KernelBundle =
-      sycl::get_kernel_bundle<sycl::bundle_state::executable>(OtherCtx, {Dev});
-
-  sycl::queue PrimaryQueue{PrimaryCtx, Dev};
-  sycl::queue SecondaryQueue{SecondaryCtx, Dev};
-
-  class UnqiueException {};
-
-  try {
-    PrimaryQueue.submit(
-        [&](sycl::handler &CGH) {
-          try {
-            CGH.use_kernel_bundle(KernelBundle);
-            FAIL() << "No exception was thrown.";
-            CGH.single_task<TestKernel>([]() {});
-          } catch (const sycl::exception &e) {
-            ASSERT_EQ(e.code().value(), static_cast<int>(sycl::errc::invalid))
-                << "sycl::exception code was not the expected "
-                   "sycl::errc::invalid.";
-            // Throw uniquely identifiable exception to distinguish between that
-            // the sycl::exception originates from the correct level.
-            throw UnqiueException{};
-          } catch (...) {
-            FAIL() << "Unexpected exception was thrown in kernel invocation "
-                      "function.";
-          }
-        },
-        SecondaryQueue);
-  } catch (const UnqiueException &) {
-    // Expected path
-  } catch (const sycl::exception &) {
-    FAIL() << "sycl::exception thrown at the wrong level.";
-  } catch (...) {
-    FAIL() << "Unexpected exception was thrown in submit.";
-  }
-}
-
 TEST(KernelBundle, EmptyDevicesKernelBundleLinkException) {
   sycl::unittest::UrMock<> Mock;
 
diff --git a/sycl/unittests/scheduler/HostTaskAndBarrier.cpp b/sycl/unittests/scheduler/HostTaskAndBarrier.cpp
index fda6e32ba281d..b115684d8f696 100644
--- a/sycl/unittests/scheduler/HostTaskAndBarrier.cpp
+++ b/sycl/unittests/scheduler/HostTaskAndBarrier.cpp
@@ -62,16 +62,16 @@ class BarrierHandlingWithHostTask : public ::testing::Test {
         CGH.host_task(BlockHostTask ? CustomHostLambda : [] {});
       };
       return QueueDevImpl->submit(sycl::detail::type_erased_cgfo_ty{L},
-                                  QueueDevImpl, nullptr, {}, true);
+                                  QueueDevImpl, {}, true);
     } else if (Type == TestCGType::KERNEL_TASK) {
       auto L = [&](handler &CGH) { CGH.single_task<TestKernel<>>([] {}); };
       return QueueDevImpl->submit(sycl::detail::type_erased_cgfo_ty{L},
-                                  QueueDevImpl, nullptr, {}, true);
+                                  QueueDevImpl, {}, true);
     } else // (Type == TestCGType::BARRIER)
     {
       auto L = [&](handler &CGH) { CGH.ext_oneapi_barrier(); };
       return QueueDevImpl->submit(sycl::detail::type_erased_cgfo_ty{L},
-                                  QueueDevImpl, nullptr, {}, true);
+                                  QueueDevImpl, {}, true);
     }
   }
 
@@ -79,7 +79,7 @@ class BarrierHandlingWithHostTask : public ::testing::Test {
   InsertBarrierWithWaitList(const std::vector<sycl::event> &WaitList) {
     auto L = [&](handler &CGH) { CGH.ext_oneapi_barrier(WaitList); };
     return QueueDevImpl->submit(sycl::detail::type_erased_cgfo_ty{L},
-                                QueueDevImpl, nullptr, {}, true);
+                                QueueDevImpl, {}, true);
   }
 
   void BuildAndCheckInnerQueueState(std::vector<EventImplPtr> &Events) {