diff --git a/runtime/command_queue/command_queue.cpp b/runtime/command_queue/command_queue.cpp
index a62061d21b..3cb4fd10b4 100644
--- a/runtime/command_queue/command_queue.cpp
+++ b/runtime/command_queue/command_queue.cpp
@@ -72,7 +72,7 @@ CommandQueue::CommandQueue(Context *context, Device *deviceId, const cl_queue_pr
             timestampPacketContainer = std::make_unique<TimestampPacketContainer>();
         }
         if (device->getExecutionEnvironment()->getHardwareInfo()->capabilityTable.blitterOperationsSupported) {
-            bcsEngine = &device->getEngine(aub_stream::EngineType::ENGINE_BCS, false);
+            bcsEngine = &device->getDeviceById(0)->getEngine(aub_stream::EngineType::ENGINE_BCS, false);
         }
     }
 
diff --git a/runtime/command_queue/command_queue_hw.h b/runtime/command_queue/command_queue_hw.h
index ae2a356946..bd6afdc3d9 100644
--- a/runtime/command_queue/command_queue_hw.h
+++ b/runtime/command_queue/command_queue_hw.h
@@ -38,7 +38,7 @@ class CommandQueueHw : public CommandQueue {
 
         if (clPriority & static_cast<cl_queue_priority_khr>(CL_QUEUE_PRIORITY_LOW_KHR)) {
             priority = QueuePriority::LOW;
-            this->gpgpuEngine = &device->getEngine(HwHelperHw<GfxFamily>::lowPriorityEngineType, true);
+            this->gpgpuEngine = &device->getDeviceById(0)->getEngine(HwHelperHw<GfxFamily>::lowPriorityEngineType, true);
         } else if (clPriority & static_cast<cl_queue_priority_khr>(CL_QUEUE_PRIORITY_MED_KHR)) {
             priority = QueuePriority::MEDIUM;
         } else if (clPriority & static_cast<cl_queue_priority_khr>(CL_QUEUE_PRIORITY_HIGH_KHR)) {
diff --git a/unit_tests/api/cl_create_command_queue_with_properties_tests.cpp b/unit_tests/api/cl_create_command_queue_with_properties_tests.cpp
index fe89627328..3cd969bf4c 100644
--- a/unit_tests/api/cl_create_command_queue_with_properties_tests.cpp
+++ b/unit_tests/api/cl_create_command_queue_with_properties_tests.cpp
@@ -5,6 +5,7 @@
  *
  */
 
+#include "core/unit_tests/helpers/debug_manager_state_restore.h"
 #include "runtime/command_queue/command_queue.h"
 #include "runtime/command_stream/command_stream_receiver.h"
 #include "runtime/device/device.h"
@@ -378,6 +379,24 @@ HWTEST_F(clCreateCommandQueueWithPropertiesApi, GivenLowPriorityWhenCreatingComm
     clReleaseCommandQueue(cmdQ);
 }
 
+using LowPriorityCommandQueueTest = ::testing::Test;
+HWTEST_F(LowPriorityCommandQueueTest, GivenDeviceWithSubdevicesWhenCreatingLowPriorityCommandQueueThenEngineFromFirstSubdeviceIsTaken) {
+    DebugManagerStateRestore restorer;
+    DebugManager.flags.CreateMultipleSubDevices.set(2);
+    MockContext context;
+    cl_queue_properties properties[] = {CL_QUEUE_PRIORITY_KHR, CL_QUEUE_PRIORITY_LOW_KHR, 0};
+    EXPECT_EQ(2u, context.getDevice(0)->getNumAvailableDevices());
+    auto cmdQ = clCreateCommandQueueWithProperties(&context, context.getDevice(0), properties, nullptr);
+
+    auto commandQueueObj = castToObject<CommandQueue>(cmdQ);
+    auto subDevice = context.getDevice(0)->getDeviceById(0);
+    auto engine = subDevice->getEngine(HwHelperHw<FamilyType>::lowPriorityEngineType, true);
+
+    EXPECT_EQ(engine.commandStreamReceiver, &commandQueueObj->getGpgpuCommandStreamReceiver());
+    EXPECT_EQ(engine.osContext, &commandQueueObj->getGpgpuCommandStreamReceiver().getOsContext());
+    clReleaseCommandQueue(cmdQ);
+}
+
 std::pair<uint32_t, QueuePriority> priorityParams[3]{
     std::make_pair(CL_QUEUE_PRIORITY_LOW_KHR, QueuePriority::LOW),
     std::make_pair(CL_QUEUE_PRIORITY_MED_KHR, QueuePriority::MEDIUM),
diff --git a/unit_tests/command_queue/command_queue_tests.cpp b/unit_tests/command_queue/command_queue_tests.cpp
index d3fecdda2f..904825e844 100644
--- a/unit_tests/command_queue/command_queue_tests.cpp
+++ b/unit_tests/command_queue/command_queue_tests.cpp
@@ -216,6 +216,34 @@ TEST(CommandQueue, givenDeviceNotSupportingBlitOperationsWhenQueueIsCreatedThenD
     EXPECT_EQ(nullptr, cmdQ.getBcsCommandStreamReceiver());
 }
 
+using CommandQueueWithSubDevicesTest = ::testing::Test;
+HWTEST_F(CommandQueueWithSubDevicesTest, givenDeviceWithSubDevicesSupportingBlitOperationsWhenQueueIsCreatedThenBcsIsTakenFromFirstSubDevice) {
+    DebugManagerStateRestore restorer;
+    DebugManager.flags.CreateMultipleSubDevices.set(2);
+    DebugManager.flags.EnableBlitterOperationsForReadWriteBuffers.set(1);
+    HardwareInfo hwInfo = *platformDevices[0];
+    bool createBcsEngine = !hwInfo.capabilityTable.blitterOperationsSupported;
+    hwInfo.capabilityTable.blitterOperationsSupported = true;
+    std::unique_ptr<MockDevice> device(MockDevice::createWithNewExecutionEnvironment<MockDevice>(&hwInfo));
+    EXPECT_EQ(2u, device->getNumAvailableDevices());
+    std::unique_ptr<OsContext> bcsOsContext;
+
+    auto subDevice = device->getDeviceById(0);
+    if (createBcsEngine) {
+        auto &engine = subDevice->getEngine(HwHelperHw<FamilyType>::lowPriorityEngineType, true);
+        bcsOsContext.reset(OsContext::create(nullptr, 1, 0, aub_stream::ENGINE_BCS, PreemptionMode::Disabled, false));
+        engine.osContext = bcsOsContext.get();
+        engine.commandStreamReceiver->setupContext(*bcsOsContext);
+    }
+    auto bcsEngine = subDevice->getEngine(aub_stream::EngineType::ENGINE_BCS, false);
+
+    CommandQueue cmdQ(nullptr, device.get(), 0);
+
+    EXPECT_NE(nullptr, cmdQ.getBcsCommandStreamReceiver());
+    EXPECT_EQ(bcsEngine.commandStreamReceiver, cmdQ.getBcsCommandStreamReceiver());
+    EXPECT_EQ(bcsEngine.osContext, &cmdQ.getBcsCommandStreamReceiver()->getOsContext());
+}
+
 TEST(CommandQueue, givenCmdQueueBlockedByReadyVirtualEventWhenUnblockingThenUpdateFlushTaskFromEvent) {
     std::unique_ptr<MockDevice> mockDevice(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
     auto context = new MockContext;