from PIL import Image
image = Image.new('RGB', (n, m))

You'll need to set up relative (label) coordinates and sizes (in cm) for all elements, you want to draw, and then calculate the corresponding image coordinates and sizes (in pixels) w.r.t. the desired resolution. That'll get somehow cumbersome, but I can't think of another way to do this independent of the resolution.

In the following, I left out the whole QR code thing to keep things at least a bit readable.

For comparison, your code as is (without the QR code thing) generates this image on my machine:

If I open that image in Photoshop, it says 9.7 cm x 7.2 cm at 72 dpi. If I calculate the resolutions by hand, I'll get the following results:

275 pixels / 7.5 cm * (2.54 cm/inch) = ca. 93 dpi
204 pixels / 5.5 cm * (2.54 cm/inch) = ca. 94 dpi

We'll need the 94 dpi later.

I approximated the relative (label) coordinates and sizes from your original image.

Now, first let's see the whole code:

from PIL import Image, ImageDraw, ImageFont

# Set up parameters
w_cm, h_cm = (7.5, 5.5)             # Real label size in cm
res_x, res_y = (300, 300)           # Desired resolution
res_y_old = 94                      # Old y resolution (204 / 5.5 * 2.54)

# Inch-to-cm factor
f = 2.54

# Determine image size w.r.t. resolution
w = int(w_cm / f * res_x)
h = int(h_cm / f * res_y)

# Create new image with proper size
img = Image.new('RGB', (w, h), color=(220, 220, 220))

# Draw elements
draw = ImageDraw.Draw(img)


def draw_text(x_cm, y_cm, font_size):
    font = ImageFont.truetype('arial.ttf', int(font_size / (res_y_old / res_y)))
    x, y = (int(x_cm / f * res_x), int(y_cm / f * res_y))
    draw.text((x, y), 'test', (0, 0, 0), font=font)


# Draw texts
draw_text(1.875, 4, 25)
draw_text(3.15, 3.25, 60)

# Polygon
coords_cm = [(0.15, 0.5), (1.35, 0.9), (1.35, 0.1)]
coords = [(int(c[0] / f * res_x), int(c[1] / f * res_y)) for c in coords_cm]
draw.polygon(tuple(coords), fill=(0, 0, 0))

# Save image
img.save('image.png', dpi=(res_x, res_y))

And, let's see the output:

If I open that image in Photoshop, it says 7.5 cm x 5.5 cm at 300 dpi, so exactly, what we wanted.

Regarding the font sizes: I guess, you set up those font sizes manually to get a certain appearance. Unfortunately, font sizes given in points are adjusted to have a certain height on monitors, but they won't scale for printing (or "printed" images). That's why, we need to scale the fonts w.r.t. the old and new resolution to keep the desired text appearance from your original image.

Everything else is repetitive converting relative coordinates and sizes. Do not hesitate to ask, if further explanations are needed!

----------------------------------------
System information
----------------------------------------
Platform:    Windows-10-10.0.16299-SP0
Python:      3.8.5
Pillow:      8.1.0
----------------------------------------

In doc Image.new I see something different.

When you use RGB then it creates 3 channels and you should use tuple (R,G,B) as color to set values in all channnels for all pixels. If you use single integer/float then it may convert it to tuple (R,G,B).

If you use L then it creates 1 channel and then you should use single integer/float to set color for all pixels

But color doesn't change number of channels.

EDIT: converting 3x8bit R,G,B to/from 24bit value

value = 1000
R = value%256
value = value//256
G = value%256
value = value//256
B = value%256

print(R,G,B)
print(R+(G*256)+(B*256*256))

Result

232 3 0
1000