Out-File when calling through log through function

You're mixing Add-Content and Out-File output, which use different default encodings. The *-Content cmdlets default to ASCII¹, whereas the Out-File cmdlet defaults to Unicode (little endian UTF-16, to be precise). UTF-16 characters are encoded as 2 bytes, whereas ASCII characters are encoded as 1 byte. Hence the gratuitious spacing in the output added by Out-File.

From the Out-File documentation:

-Encoding

Specifies the type of character encoding used in the file. The acceptable values for this parameter are:

[...]

Unicode is the default.

From the Add-Content documentation:

-Encoding

Specifies the file encoding. The default is ASCII.

You see the 2 bytes of the Unicode characters displayed as 2 characters because the file was originally created by Add-Content (using that cmdlet's default encoding). Had the file originally been created as a Unicode file and you wrote ASCII text to it afterwards then you'd see what is called "mojibake" (two ASCII characters being displayed as one Unicode character). That normally shouldn't happen when appending to a Unicode file with Add-Content, though, because the cmdlet honors the BOM (Byte Order Mark) that indicates the encoding used for the file.

The general recommendation is not to mix *-Content cmdlets with Out-File. Use one or the other, and stick with it. If for some reason you must use Out-File along with *-Content cmdlets enforce the desired encoding via the parameter -Encoding.

With that said, if you already have a logging function present: use it for all the logging. Do not log some lines one way and others a different way. Extend your logging function so that it accepts input from the pipeline:

function LogWrite {
    [CmdletBinding()]
    Param (
        [Parameter(Position=0, Mandatory=$false, ValueFromPipeline=$true)]
        [string]$logstring = ""
    )

    Process {
        $logstring | Add-Content $Logfile
    }
}

so that you can use it like this:

LogWrite "something"

or like this:

Get-ChildItem | LogWrite

or like this:

Get-ChildItem | Out-String | LogWrite

depending on the kind of log output you want to get.

I would also recommend adding a timestamp inside the logging function rather than adding timestamps to individual strings:

"$(Get-Timestamp) ${logstring}" | Add-Content $Logfile

¹ Yes, I am aware that technically the encoding is ANSI (or rather one of the many ANSI encodings), and that actual ASCII encoding uses 7 bits, not 8 bits like ANSI. However, in the context of the question that is a distinction without a difference, because the problem at hand is the fact that UTF-16 characters are stored using 2 bytes per character, while ASCII and ANSI characters alike are stored using just one byte per character.

Here's a simple logging function that will accomplish what you want:

function Write-Log {
    [CmdletBinding()]
    param(
        [Parameter(ValueFromPipeline)]
        [string] $Message,

        [string] $Path = "$sourceDir$fileName$(Get-Date -UFormat %Y%m%d_%H%M%S).log"
    )

    process {
        "$(Get-Date -UFormat '[%m/%d/%Y %H:%M:%S]') $Message" |
            Out-File -FilePath $Path -Append -Encoding UTF8 -Force
    }
}

In use:

Write-Log 'Created timestamp'
Write-Log "Looking for all files with a date modified older than $date"

if ($files = Get-ChildItem -Path $source | Get-ChildItem | Where-Object LastWriteTime -lt $date) {
    Write-Log 'There are files to transfer'
    Write-Log 'Here are the files and directories I am working on today'

    $files.FullName | Write-Log

    Get-ChildItem -Path $sourceDir -Recurse |
        ForEach-Object {
            $dest = $targetDir + $_.FullName.Substring($sourceDir.Length)

            if (-not $dest.Contains('.') -and -not (Test-Path -Path $dest)) {
                New-Item -Path $dest -ItemType Directory
            }

            Copy-Item -Path $_.FullName -Destination $dest -Force -PassThru |
                ForEach-Object FullName |
                Write-Log
        }
} else {
    Write-Log 'No files to transfer'
    Write-Log 'Ending'
}