Small workaround to show thumbnail before loading actual image with Coil.

CoilWithPlaceholder.kt

        var isOriginalImageLoaded = false

        // Thumbnail Request
        val thumbRequest = ImageRequest.Builder(ctx)
            .data(thumbUrl)
            .target(
                onSuccess = { result ->
                    // If highRes image is not loaded yet,
                    // show the thumbnail
                    if (!isOriginalImageLoaded) {
                        binding.headerImage.setImageDrawable(result)
                    } 
                }
            )
            .build()

        imageLoader.enqueue(thumbRequest)
        
         val highResRequest = ImageRequest.Builder(ctx)
            .data(highResUrl)
            .target(
                onSuccess = { result ->
                    isOriginalImageLoaded = true
                    binding.headerImage.setImageDrawable(result)
                },
                onError = { onFailed() }
            )
            .build()
            
        imageLoader.enqueue(highResRequest)

Made some modifications using an Extension Function

fun ImageView.loadWithQuality(
    highQuality: String,
    lowQuality: String,
    placeholderRes: Int? = null,
    errorRes: Int? = null
) {

    placeholderRes?.let {
        setImageResource(placeholderRes)
    }

    var isHighQualityLoaded = false

    class CallbackImageViewTarget(val callback: () -> Boolean) : ImageViewTarget(this) {
        override fun onSuccess(result: Drawable) {
            if (callback()) {
                super.onSuccess(result)
            }
        }
    }

    val lowQualityRequest = ImageRequest.Builder(context).apply {
        data(lowQuality)
        target(CallbackImageViewTarget(
            callback = {
                return@CallbackImageViewTarget !isHighQualityLoaded
            }
        ))
    }.build()

    val lowQualityLoader = context.imageLoader.enqueue(lowQualityRequest)

    val highQualityRequest = ImageRequest.Builder(context).apply {
        data(highQuality)
        errorRes?.let { error(errorRes) }
        target(CallbackImageViewTarget(
            callback = {
                isHighQualityLoaded = true
                if (!lowQualityLoader.isDisposed) {
                    lowQualityLoader.dispose()
                }
                return@CallbackImageViewTarget true
            }
        ))
    }.build()

    context.imageLoader.enqueue(highQualityRequest)

}

Thanks for checking and improving it :)