I have discovered a workaround that works with stylesheets, although it lacks flexibility. Instead of setting the background of the QProgressBar chunks, you can set the background of the QProgressBar itself and then apply an inverted appearance:

QProgressBar.setInvertedAppearance(True)

The code above is specific to PyQt5, so you will need to find the equivalent for C++. When using the following stylesheet, keep in mind that the gradient mentioned is intended for a vertical progress bar, so adjustments will be necessary to make it fit a horizontal bar. Additionally, remember to use width: instead of height: in that case.

QProgressBar{
    border: 2px solid grey;
    border-radius: 3px;
    text-align: center;
    background-color: qlineargradient(spread:pad, x1:0.5, y1:1, x2:0.5, y2:0, 
                               stop:0 rgba(0, 170, 0, 255), stop:0.33 rgba(255, 255, 0, 255),
                               stop:0.6 rgba(232, 165, 0, 255), stop:1 rgba(189, 0, 0, 255));
}

QProgressBar::chunk {
    background-color: rgb(50,50,50);
    margin: 0px;
    height: 5px;
}

One drawback of this method is that you cannot use chunks with margins, and you must reverse the values you set for progress. For example, 100 becomes 0, 70 becomes 30, and so on.

To create a continuous progress bar, set the height of the chunks to a minimal value like 0.5px. Hopefully, this solution will help alleviate the need for subclassing QProgressBar and implementing the painter for some individuals!

If you're looking to achieve a specific aesthetic that isn't possible with the current stylesheet properties, consider creating a subclass of QProgressBar and customizing the painting functionality to tailor it to your desired look.

Reiterating what @Gabriel de Grimouard previously mentioned, the recommended approach is to subclass QProgressBar and override the paint method. However, there is an alternative method (albeit a bit unconventional) - subclass QProgressBar and modify the setValue slot.

QString style_0_60      = "QProgressBar::chunk{ background-color: green; }";
QString style_60_80     = "QProgressBar::chunk{ background-color: orange; }";
QString style_80_100    = "QProgressBar::chunk{ background-color: red; }";

#include <QProgressBar>

class MyProgressBar : public QProgressBar
{
public:
    MyProgressBar();
    void    setValue(int value);
};

void MyProgressBar::setValue(int value)
{
    if(value >= 0 && value < 60)
        this->setStyleSheet(style_0_60);
    else if (value >= 60 && value < 80)
        this->setStyleSheet(style_60_80);
    else
        this->setStyleSheet(style_80_100);

    QProgressBar::setValue(value);
}

After finding inspiration from @Miki's example, I decided to take it a step further. While the original was in solid colors, I wanted to create a gradient effect by tweaking the cpp code. I believe that my contribution enhances the discussion on incorporating multiple colors in a progress bar.

int value = checkValue();
int position = QStyle::sliderPositionFromValue(minValue(), maxValue(), value, getWidth());

QPainter painter(this);

QLinearGradient gradient(this->rect().topLeft(), this->rect().bottomRight());
gradient.setColorAt(0, Qt::blue);
gradient.setColorAt(0.3, QColor(255, 192, 203));
gradient.setColorAt(1, Qt::purple);
QRect linearRect(this->rect().topLeft(), this->rect().bottomRight());
painter.fillRect(linearRect, gradient);

painter.setPen(Qt::darkGray);
painter.setBrush(QBrush(Qt::darkGray));
painter.drawRect(position, 0, getWidth(), getHeight());

One approach could be to first paint the entire gradient bar and then selectively draw the desired portion.

https://i.sstatic.net/oBHef.gif

Credit for some of the code goes to @Miki, much appreciated @Miki

void ColoredProgressBar::paintEvent(QPaintEvent* e) {
    int val = value();
    int w = width();
    int h = height();
    int pos = QStyle::sliderPositionFromValue(minimum(), maximum(), val, width());

    // Paint on pixmap
    QPixmap pixmap(w, h);
    QPainter pixmapPainter(&pixmap);
    QLinearGradient linearGradient(0, 0, w, h);
    linearGradient.setColorAt(0, Qt::green);
    linearGradient.setColorAt(0.5, Qt::yellow);
    linearGradient.setColorAt(1, Qt::red);

    QBrush pixmapBrush(linearGradient);
    pixmapPainter.setBrush(pixmapBrush);
    pixmapPainter.drawRect(0, 0, width(), height());

    // Paint the progress bar
    QPainter painter(this);
    QBrush brush(pixmap);
    painter.setBrush(brush);
    painter.drawRect(0, 0, pos, height());

    // Paint background
    painter.setPen(Qt::lightGray);
    painter.setBrush(QBrush(Qt::lightGray));
    painter.drawRect(pos, 0, width(), height());

    // Paint text
    painter.setPen(Qt::black);
    painter.setBrush(QBrush(Qt::black));
    painter.drawText(0, 0, width(), height(), Qt::AlignCenter, QString::number(val) + "%");
}

If you're looking to achieve the effect demonstrated in Awin's answer using only stylesheets, there is a simple way to do so. You won't have to create a custom progress bar class or override the paintEvent. Just make sure to update the style with setStyle whenever the progress bar value changes. Utilizing Qt's signal/slot system and the valueChanged signal from the progress bar will help with this process.

Here is a function you can create:

auto generateProgressBarStyle(double fillRatio) -> QString
{
    double x1 = 1. - fillRatio;
    double x2 = x1 + 1.;

    QString style = "QProgressBar::chunk:horizontal{"
                    + "background: QLinearGradient(x1 : " 
                    + QString::number(x1)
                    + ", y1 : 0, x2 : " 
                    + QString::number(x2)
                    + ", y2 : 0, stop : 0 #009900, stop : 0.60 #DDDD00,"
                    + " stop : 0.75 #DDBB00, stop : 1 #DD0000);}";

    return style;
}

The fillRatio parameter represents the current value divided by the maximum value. This function adjusts the x1 and x2 values of the linear gradient based on the fill ratio of the progress bar.

While I'm still learning Qt, I can't determine the performance impact of this method. Creating a custom progress bar class, as suggested in other answers, may be more robust and efficient. However, for quick solutions, this approach has proven sufficient for my needs.