diff --git a/Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController.cpp b/Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController.cpp
new file mode 100644
index 00000000..ed018878
--- /dev/null
+++ b/Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController.cpp
@@ -0,0 +1,133 @@
+/*-----------------------------------------*\
+|  AsusAuraHeadsetStandController.cpp       |
+|                                           |
+|  Driver for ASUS Aura RGB USB             |
+|  lighting controller                      |
+|                                           |
+|  Mola19 06/04/2021                        |
+\*-----------------------------------------*/
+
+#include "AsusAuraHeadsetStandController.h"
+
+#include <cstring>
+
+AuraHeadsetStandController::AuraHeadsetStandController(hid_device* dev_handle, const char* path)
+{
+    dev         = dev_handle;
+    location    = path;
+}
+
+AuraHeadsetStandController::~AuraHeadsetStandController()
+{
+	hid_close(dev);
+}
+
+std::string AuraHeadsetStandController::GetDeviceLocation()
+{
+    return("HID: " + location);
+}
+
+std::string AuraHeadsetStandController::GetSerialString()
+{
+    wchar_t serial_string[128];
+    int ret = hid_get_serial_number_string(dev, serial_string, 128);
+
+    if(ret != 0)
+    {
+        return("");
+    }
+
+    std::wstring return_wstring = serial_string;
+    std::string return_string(return_wstring.begin(), return_wstring.end());
+
+    return(return_string);
+}
+
+void AuraHeadsetStandController::UpdateLeds
+    (
+    std::vector<RGBColor>    colors
+    )
+{
+    unsigned char usb_buf_0[365];
+
+    memset(usb_buf_0, 0x00, sizeof(usb_buf_0));
+
+    usb_buf_0[0x00]   = 0x00;
+    usb_buf_0[0x01]   = 0xC0;
+    usb_buf_0[0x02]   = 0x81;
+    usb_buf_0[0x03]   = 0x00;
+    usb_buf_0[0x04]   = 0x00;
+
+    for(unsigned int i = 0; i < 60; i += 4)
+    {
+        usb_buf_0[5 + i]   = 0x00;
+        usb_buf_0[6 + i]   = RGBGetRValue(colors[i / 4]);
+        usb_buf_0[7 + i]   = RGBGetGValue(colors[i / 4]);
+        usb_buf_0[8 + i]   = RGBGetBValue(colors[i / 4]);
+    }
+
+    hid_write(dev, usb_buf_0, 65);
+
+    unsigned char usb_buf_1[65];
+
+    memset(usb_buf_1, 0x00, sizeof(usb_buf_1));
+
+    usb_buf_1[0x00]   = 0x00;
+    usb_buf_1[0x01]   = 0xC0;
+    usb_buf_1[0x02]   = 0x81;
+    usb_buf_1[0x03]   = 0x01;
+    usb_buf_1[0x04]   = 0x00;
+
+    for(unsigned int i = 0; i < 12; i += 4)
+    {
+        usb_buf_1[5 + i]   = 0x00;
+        usb_buf_1[6 + i]   = RGBGetRValue(colors[(i / 4) + 15]);
+        usb_buf_1[7 + i]   = RGBGetGValue(colors[(i / 4) + 15]);
+        usb_buf_1[8 + i]   = RGBGetBValue(colors[(i / 4) + 15]);
+    }
+
+    hid_write(dev, usb_buf_1, 65);
+}
+
+void AuraHeadsetStandController::UpdateDevice
+    (
+    unsigned char   mode,
+    unsigned char   red,
+    unsigned char   grn,
+    unsigned char   blu,
+    unsigned char   speed,
+    bool            save
+    )
+{
+    unsigned char usb_buf[65];
+
+    memset(usb_buf, 0x00, sizeof(usb_buf));
+
+    usb_buf[0x00]   = 0x00;
+    usb_buf[0x01]   = 0x51;
+    usb_buf[0x02]   = 0x28;
+    usb_buf[0x03]   = 0x00;
+    usb_buf[0x04]   = 0x00;
+    usb_buf[0x05]   = mode;
+    usb_buf[0x06]   = speed;
+    usb_buf[0x07]   = 0x04;
+    usb_buf[0x08]   = 0x00;
+    usb_buf[0x09]   = 0x00;
+    usb_buf[0x0a]   = red;
+    usb_buf[0x0b]   = grn;
+    usb_buf[0x0c]   = blu;
+    hid_write(dev, usb_buf, 65);
+
+    if(save)
+    {
+        unsigned char usb_save_buf[65];
+
+        memset(usb_save_buf, 0x00, sizeof(usb_save_buf));
+        
+        usb_save_buf[0x00]   = 0x00;
+        usb_save_buf[0x01]   = 0x50;
+        usb_save_buf[0x02]   = 0x55;
+        
+        hid_write(dev, usb_save_buf, 65);
+    }
+}
diff --git a/Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController.h b/Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController.h
new file mode 100644
index 00000000..222c557c
--- /dev/null
+++ b/Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController.h
@@ -0,0 +1,59 @@
+/*-----------------------------------------*\
+|  AsusAuraHeadsetStandController.h         |
+|                                           |
+|  Definitions and types for ASUS Aura      |
+|  USB RGB lighting controller              |
+|                                           |
+|  Mola19 06/04/2021                        |
+\*-----------------------------------------*/
+
+#include "RGBController.h"
+
+#include <hidapi/hidapi.h>
+
+#pragma once
+
+enum
+{
+    AURA_HEADSET_STAND_ZONE_UNDERGLOW   = 0,
+    AURA_HEADSET_STAND_ZONE_LOGO        = 1
+};
+
+enum
+{
+    AURA_HEADSET_STAND_MODE_DIRECT      = 0,
+    AURA_HEADSET_STAND_MODE_STATIC      = 1,
+    AURA_HEADSET_STAND_MODE_BREATHING   = 2,
+    AURA_HEADSET_STAND_MODE_STROBING    = 3,
+    AURA_HEADSET_STAND_MODE_COLOR_CYCLE = 4,
+    AURA_HEADSET_STAND_MODE_RAINBOW     = 5
+};
+
+class AuraHeadsetStandController
+{
+public:
+    AuraHeadsetStandController(hid_device* dev_handle, const char* path);
+    virtual ~AuraHeadsetStandController();
+
+    std::string GetDeviceLocation();
+    std::string GetSerialString();
+
+    void UpdateLeds
+        (
+        std::vector<RGBColor>    colors
+        );
+
+    void UpdateDevice
+        (
+        unsigned char   mode,
+        unsigned char   red,
+        unsigned char   grn,
+        unsigned char   blu,
+        unsigned char   speed,
+        bool            save
+        );
+
+private:
+    hid_device*                 dev;
+    std::string                 location;
+};
diff --git a/Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp b/Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp
index 22a5d330..a680a88b 100644
--- a/Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp
+++ b/Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp
@@ -1,10 +1,12 @@
 #include "Detector.h"
 #include "AsusAuraAddressableController.h"
+#include "AsusAuraHeadsetStandController.h"
 #include "AsusAuraKeyboardController.h"
 #include "AsusAuraMainboardController.h"
 #include "AsusAuraMouseController.h"
 #include "RGBController.h"
 #include "RGBController_AsusAuraUSB.h"
+#include "RGBController_AsusAuraHeadsetStand.h"
 #include "RGBController_AsusAuraKeyboard.h"
 #include "RGBController_AsusAuraMouse.h"
 #include <stdexcept>
@@ -30,6 +32,7 @@
 #define AURA_ROG_CHAKRAM_WIRELESS_PID           0x18E5
 #define AURA_ROG_CHAKRAM_WIRED_1_PID            0x18E3
 #define AURA_ROG_CHAKRAM_WIRED_2_PID            0x1958
+#define AURA_ROG_THRONE_QI_PID                  0x18C5
 
 void DetectAsusAuraUSBTerminal(hid_device_info* info, const std::string& name)
 {
@@ -102,6 +105,18 @@ void DetectAsusAuraUSBMice(hid_device_info* info, const std::string& name)
     }
 }
 
+void DetectAsusAuraUSBHeadsetStand(hid_device_info* info, const std::string& name)
+{
+    hid_device* dev = hid_open_path(info->path);
+    if(dev)
+    {
+        AuraHeadsetStandController* controller = new AuraHeadsetStandController(dev, info->path);
+        RGBController_AuraHeadsetStand* rgb_controller = new RGBController_AuraHeadsetStand(controller);
+        rgb_controller->name = name;
+        ResourceManager::get()->RegisterRGBController(rgb_controller);
+    }
+}
+
 REGISTER_HID_DETECTOR   ("ASUS ROG AURA Terminal",              DetectAsusAuraUSBTerminal,      AURA_USB_VID, AURA_TERMINAL_PID);
 REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",               DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_1_PID);
 REGISTER_HID_DETECTOR   ("ASUS Aura Addressable",               DetectAsusAuraUSBAddressable,   AURA_USB_VID, AURA_ADDRESSABLE_2_PID);
@@ -119,4 +134,5 @@ REGISTER_HID_DETECTOR_IP("ASUS ROG Chakram (Wireless)",         DetectAsusAuraUS
 REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_1_PID,             0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("Asus ROG Chakram (Wired)",            DetectAsusAuraUSBMice,          AURA_USB_VID, AURA_ROG_CHAKRAM_WIRED_2_PID,             0,  0xFF01);
 REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare",                DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PID,                 1,  0xFF00);
-REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID,         1,  0xFF00);
\ No newline at end of file
+REGISTER_HID_DETECTOR_IP("ASUS ROG Strix Flare PNK LTD",        DetectAsusAuraUSBKeyboards,     AURA_USB_VID, AURA_ROG_STRIX_FLARE_PNK_LTD_PID,         1,  0xFF00);
+REGISTER_HID_DETECTOR_I ("ASUS ROG Throne QI",         			DetectAsusAuraUSBHeadsetStand,  AURA_USB_VID, AURA_ROG_THRONE_QI_PID, 					0);
diff --git a/Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.cpp b/Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.cpp
new file mode 100644
index 00000000..57f04886
--- /dev/null
+++ b/Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.cpp
@@ -0,0 +1,182 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraHeadsetStand.cpp   |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 06/04/2021                        |
+\*-----------------------------------------*/
+
+#include "RGBController_AsusAuraHeadsetStand.h"
+
+RGBController_AuraHeadsetStand::RGBController_AuraHeadsetStand(AuraHeadsetStandController* aura_ptr)
+{
+    aura        = aura_ptr;
+
+    name        = "ASUS Aura Headset Stand";
+    vendor      = "ASUS";
+    type        = DEVICE_TYPE_HEADSET_STAND;
+    description = "ASUS Aura Headset Stand Device";
+    location    = aura->GetDeviceLocation();
+    serial      = aura->GetSerialString();
+
+    mode Direct;
+    Direct.name       = "Direct";
+    Direct.value      = AURA_HEADSET_STAND_MODE_DIRECT;
+    Direct.flags      = MODE_FLAG_HAS_PER_LED_COLOR;
+    Direct.color_mode = MODE_COLORS_PER_LED;
+    modes.push_back(Direct);
+
+    mode Static;
+    Static.name       = "Static";
+    Static.value      = AURA_HEADSET_STAND_MODE_STATIC;
+    Static.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Static.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Static.colors_min = 1;
+    Static.colors_max = 1;
+    Static.colors.resize(1);
+    modes.push_back(Static);
+
+    mode Breathing;
+    Breathing.name       = "Breathing";
+    Breathing.value      = AURA_HEADSET_STAND_MODE_BREATHING;
+    Breathing.flags      = MODE_FLAG_HAS_SPEED | MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Breathing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Breathing.speed_min  = 0;
+    Breathing.speed_max  = 255;
+    Breathing.speed      = 127;
+    Breathing.colors_min = 1;
+    Breathing.colors_max = 1;
+    Breathing.colors.resize(1);
+    modes.push_back(Breathing);
+
+    mode Strobing;
+    Strobing.name       = "Strobing";
+    Strobing.value      = AURA_HEADSET_STAND_MODE_STROBING;
+    Strobing.flags      = MODE_FLAG_HAS_MODE_SPECIFIC_COLOR;
+    Strobing.color_mode = MODE_COLORS_MODE_SPECIFIC;
+    Strobing.colors_min = 1;
+    Strobing.colors_max = 1;
+    Strobing.colors.resize(1);
+    modes.push_back(Strobing);
+
+    mode SpectrumCycle;
+    SpectrumCycle.name       = "Spectrum Cycle";
+    SpectrumCycle.value      = AURA_HEADSET_STAND_MODE_COLOR_CYCLE;
+    SpectrumCycle.flags      = MODE_FLAG_HAS_SPEED;
+    SpectrumCycle.speed_min  = 0;
+    SpectrumCycle.speed_max  = 255;
+    SpectrumCycle.speed      = 127;
+    SpectrumCycle.color_mode = MODE_COLORS_NONE;
+    modes.push_back(SpectrumCycle);
+
+    mode Rainbow;
+    Rainbow.name       = "Rainbow";
+    Rainbow.value      = AURA_HEADSET_STAND_MODE_RAINBOW;
+    Rainbow.flags      = MODE_FLAG_HAS_SPEED;
+    Rainbow.speed_min  = 0;
+    Rainbow.speed_max  = 255;
+    Rainbow.speed      = 127;
+    modes.push_back(Rainbow);
+    SetupZones();
+}
+
+RGBController_AuraHeadsetStand::~RGBController_AuraHeadsetStand()
+{
+	delete aura;
+}
+
+void RGBController_AuraHeadsetStand::SetupZones()
+{
+    zone underglow_zone;
+
+    underglow_zone.name         = "Underglow";
+    underglow_zone.type         = ZONE_TYPE_LINEAR;
+    underglow_zone.leds_min     = 17;
+    underglow_zone.leds_max     = 17;
+    underglow_zone.leds_count   = 17;
+    underglow_zone.matrix_map   = NULL;
+
+    zones.push_back(underglow_zone);
+
+    for(unsigned int i = 0; i < 17; i++)
+    {
+        led underglow_led;
+
+        underglow_led.name      = "Underglow LED " + std::to_string(i);
+
+        leds.push_back(underglow_led);
+    }
+
+    zone logo_zone;
+
+    logo_zone.name              = "Logo";
+    logo_zone.type              = ZONE_TYPE_SINGLE;
+    logo_zone.leds_min          = 1;
+    logo_zone.leds_max          = 1;
+    logo_zone.leds_count        = 1;
+    logo_zone.matrix_map        = NULL;
+
+    zones.push_back(logo_zone);
+
+    led logo_led;
+
+    logo_led.name               = "Logo LED";
+
+    leds.push_back(logo_led);
+
+    SetupColors();
+}
+
+void RGBController_AuraHeadsetStand::ResizeZone(int /*zone*/, int /*new_size*/)
+{
+    /*---------------------------------------------------------*\
+    | This device does not support resizing zones               |
+    \*---------------------------------------------------------*/
+}
+
+void RGBController_AuraHeadsetStand::DeviceUpdateLEDs()
+{
+    aura->UpdateLeds(std::vector<RGBColor>(colors));
+}
+
+void RGBController_AuraHeadsetStand::UpdateZoneLEDs(int /*zone*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AuraHeadsetStand::UpdateSingleLED(int /*led*/)
+{
+    DeviceUpdateLEDs();
+}
+
+void RGBController_AuraHeadsetStand::SetCustomMode()
+{
+    active_mode = 0;
+}
+
+
+void RGBController_AuraHeadsetStand::DeviceUpdateMode()
+{
+    unsigned char red = 0;
+    unsigned char grn = 0;
+    unsigned char blu = 0;
+    switch(modes[active_mode].value)
+    {
+        case 0:
+            aura->UpdateLeds(std::vector<RGBColor>(colors));
+            break;
+        case 1:
+        case 2:
+        case 3:
+            red = RGBGetRValue(modes[active_mode].colors[0]);
+            grn = RGBGetGValue(modes[active_mode].colors[0]);
+            blu = RGBGetBValue(modes[active_mode].colors[0]);
+            aura->UpdateDevice(modes[active_mode].value, red, grn, blu, modes[active_mode].speed, false);
+            break;
+        case 4:
+        case 5:
+            aura->UpdateDevice(modes[active_mode].value, red, grn, blu, modes[active_mode].speed, false);
+            break;
+    }
+}
diff --git a/Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.h b/Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.h
new file mode 100644
index 00000000..c4d94b86
--- /dev/null
+++ b/Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.h
@@ -0,0 +1,33 @@
+/*-----------------------------------------*\
+|  RGBController_AsusAuraHeadsetStand.h     |
+|                                           |
+|  Generic RGB Interface for Asus Aura      |
+|  USB controller driver                    |
+|                                           |
+|  Mola19 06/04/2021                        |
+\*-----------------------------------------*/
+
+#pragma once
+#include "RGBController.h"
+#include "AsusAuraHeadsetStandController.h"
+
+class RGBController_AuraHeadsetStand : public RGBController
+{
+public:
+    RGBController_AuraHeadsetStand(AuraHeadsetStandController* aura_ptr);
+    ~RGBController_AuraHeadsetStand();
+
+    void        SetupZones();
+
+    void        ResizeZone(int zone, int new_size);
+
+    void        DeviceUpdateLEDs();
+    void        UpdateZoneLEDs(int zone);
+    void        UpdateSingleLED(int led);
+
+    void        SetCustomMode();
+    void        DeviceUpdateMode();
+
+private:
+    AuraHeadsetStandController*  aura;
+};
diff --git a/OpenRGB.pro b/OpenRGB.pro
index cbacfbf1..adac0298 100644
--- a/OpenRGB.pro
+++ b/OpenRGB.pro
@@ -187,9 +187,11 @@ HEADERS +=
     Controllers/AsusAuraSMBusController/RGBController_AsusAuraSMBus.h                           \
     Controllers/AsusAuraUSBController/AsusAuraUSBController.h                                   \
     Controllers/AsusAuraUSBController/AsusAuraAddressableController.h                           \
+    Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController.h                          \
     Controllers/AsusAuraUSBController/AsusAuraKeyboardController.h                              \
     Controllers/AsusAuraUSBController/AsusAuraMainboardController.h                             \
     Controllers/AsusAuraUSBController/AsusAuraMouseController.h                                 \
+    Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.h                      \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.h                          \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.h                             \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.h                               \
@@ -472,10 +474,12 @@ SOURCES +=
     Controllers/AsusAuraSMBusController/RGBController_AsusAuraSMBus.cpp                         \
     Controllers/AsusAuraUSBController/AsusAuraUSBController.cpp                                 \
     Controllers/AsusAuraUSBController/AsusAuraAddressableController.cpp                         \
+    Controllers/AsusAuraUSBController/AsusAuraHeadsetStandController.cpp                        \
     Controllers/AsusAuraUSBController/AsusAuraKeyboardController.cpp                            \
     Controllers/AsusAuraUSBController/AsusAuraMainboardController.cpp                           \
     Controllers/AsusAuraUSBController/AsusAuraMouseController.cpp                               \
     Controllers/AsusAuraUSBController/AsusAuraUSBControllerDetect.cpp                           \
+    Controllers/AsusAuraUSBController/RGBController_AsusAuraHeadsetStand.cpp                    \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraKeyboard.cpp                        \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraMouse.cpp                           \
     Controllers/AsusAuraUSBController/RGBController_AsusAuraUSB.cpp                             \