I don't believe Quick Fields can generate PDF documents at this time, however, I am doing this within a SDK script and it is not terribly complicated; however, you need to be mindful of server resources (primarily CPU in my experience) and workflow configuration (such as the script domain model).

Below is the code I am using to generate my PDFs. Note that I preserve both the PDF and the TIFF images on the document, and I apply variable compression quality to the PDF to control the size of the resulting files, which you may or may not need to do depending on what you are processing.

namespace WorkflowActivity.Scripting.GeneratePDF
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Data.SqlClient;
    using System.Text;
    using System.IO;
    using Laserfiche.RepositoryAccess;
    using Laserfiche.DocumentServices;

    public class GeneratePDF : RAScriptClass102
    {
        protected override void Execute()
        {
            // Set variables for image size, text size, document size, and average bytes per page
            long imageSize = 0;
            long textSize = 0;
            long bytesPerPage = 0;
            int compression = 0;

            // Get and lock source document
            DocumentInfo doc = (DocumentInfo)this.BoundEntryInfo;
            doc.Lock(LockType.Exclusive);

            // Try to generate and attach PDF
            try{
                // Retrieve page count
                int pageCount = doc.PageCount;

                // Read values of each page
                PageInfoReader pageReader = doc.GetPageInfos();
                foreach (PageInfo page in pageReader){
                    // Track cumulative page and text sizes
                    // to determine what level of compression to apply
                    imageSize += page.ImageDataSize;
                    textSize += page.TextDataSize;
                }

                // Get average bytes per page
                bytesPerPage = imageSize/pageCount;

                // Initialize compression variables
                int minSize = 62500;
                int midSize = 250000;
                int maxSize = 1000000;

                // Evaluate average page size
                if (bytesPerPage < minSize){
                    // default for low-quality images
                    compression = 90;
                }
                else {
                    // low-to-medium quality images
                    if (bytesPerPage < midSize){
                        compression = 75;
                    }
                    else {
                        // medium-to-high quality images
                        if (bytesPerPage < maxSize){
                            compression = 50;
                        }
                        // high-quality images
                        else {
                            compression = 25;
                        }
                    }
                }

                // Initialize document export
                DocumentExporter dExp = new DocumentExporter();

                // Configure document exporter settings
                dExp.CompressionQuality = compression;
                dExp.IncludeAnnotations = true;
                dExp.BlackoutRedactions = true;
                dExp.PageFormat = DocumentPageFormat.Jpeg;

                // Set PDF export options to flatten annotations and include searchable text
                PdfExportOptions ExportOptions = PdfExportOptions.RenderAnnotationsAsImage | PdfExportOptions.IncludeText;

                // Initialize memory stream and export PDF
                MemoryStream ms = new MemoryStream();
                dExp.ExportPdf(doc, doc.AllPages, ExportOptions, ms);

                // Write PDF to document
                using(Stream eDocStream = doc.WriteEdoc("application/pdf",ms.ToArray().LongLength)){
                    eDocStream.Write(ms.ToArray(),0,ms.ToArray().Length);
                }

                // Update document extension and save changes
                doc.Extension = ".pdf";

                // Save changes
                doc.Save();
            }

            // Ensure tokens are always updated and document is always unlocked
            finally{
                // Confirm eDoc attached and get eDoc Size
                SetTokenValue("eDoc",doc.IsElectronicDocument);
                SetTokenValue("eDocSize",doc.ElecDocumentSize);
                SetTokenValue("imageSize",imageSize);
                SetTokenValue("textSize",textSize);
                SetTokenValue("Quality",compression);

                // Release document
                doc.Unlock();
                doc.Dispose();
            }
        }
    }
}

I call this script within my workflow, then evaluate the output tokens to confirm that the PDF was generated without errors and track various information.

Also note that I have a Try-Finally instead of a Try-Catch-Finally as I personally prefer to put the script activity in a Try-Catch in workflow to handle errors outside of the script for this particular process.