Bubba, you've got this genius way of finding a one-step solution to any problem. I went with your RGBH struct approach (which makes sense to be now, but there's no way I would've thought of it myself), and it works alot better so far, however, I'm having a slight problem...

(I'll post the code/output and outline the problems below, feel free to skip the code for now)

Code:
#define WIN_32_LEAN_AND_MEAN

#include <Stdlib.h>
#include <Stdio.h>
#include <IO.h>
#include <FCNTL.h>

struct CUSTOMBITMAPHEADER
{
	unsigned short	Type;
	unsigned long	Size;
	unsigned short	Reserved1;
	unsigned short	Reserved2;
	unsigned long	OffBits;
	unsigned long	RemainingSize;
	unsigned long	Width;
	unsigned long	Height;
	unsigned short	Planes;
	unsigned short	BitCount;
	unsigned long	Compression;
	unsigned long	SizeImage;
	unsigned long	XPelsPerMeter;
	unsigned long	YPelsPerMeter;
	unsigned long	ClrUsed;
	unsigned long	ClrImportant;
};

struct RGBH
{
	unsigned char R;
	unsigned char G;
	unsigned char B;
	unsigned char H;
};

void	CompleteHeader(CUSTOMBITMAPHEADER *BitmapHeader, int FileHandle);
RGBH *	CompletePixels(CUSTOMBITMAPHEADER *BitmapHeader, int FileHandle);
void	DisplayHeader(CUSTOMBITMAPHEADER *BitmapHeader, FILE *Outstream);
void	DisplayPixels(CUSTOMBITMAPHEADER *BitmapHeader, RGBH *Buffer, FILE *Outstream);

int main(void)
{
	CUSTOMBITMAPHEADER BitmapHeader;

	char	iPath[250];
	int	FileHandle	= 0;
	RGBH	*Buffer		= NULL;

	printf("Enter Input Path: ");
	fscanf(stdin, "%s", iPath);
	printf("\n");

	printf("Opening File:\t");
	FileHandle = _open(iPath, _O_TEXT|_O_RDONLY);
	
	if(FileHandle != 0)
	{
		printf("Succeeded\n");
		
		CompleteHeader(&BitmapHeader, FileHandle);
		Buffer = CompletePixels(&BitmapHeader, FileHandle);

		if(Buffer != NULL)
		{
			DisplayHeader(&BitmapHeader, stdout);
			DisplayPixels(&BitmapHeader, Buffer, stdout);
		}
	}
	else
	{
		printf("Failed\n");
	}

	if(Buffer != NULL)
	{
		free(Buffer);
		Buffer = NULL;
	}

	if(FileHandle != 0)
		_close(FileHandle);

	printf("\n\n");
	return 0;
}

void CompleteHeader(CUSTOMBITMAPHEADER *BitmapHeader, int FileHandle)
{
	_read(FileHandle, &(BitmapHeader->Type),		sizeof(BitmapHeader->Type));
	_read(FileHandle, &(BitmapHeader->Size),		sizeof(BitmapHeader->Size));
	_read(FileHandle, &(BitmapHeader->Reserved1),		sizeof(BitmapHeader->Reserved1));
	_read(FileHandle, &(BitmapHeader->Reserved2),		sizeof(BitmapHeader->Reserved2));
	_read(FileHandle, &(BitmapHeader->OffBits),		sizeof(BitmapHeader->OffBits));
	_read(FileHandle, &(BitmapHeader->RemainingSize),	sizeof(BitmapHeader->Size));
	_read(FileHandle, &(BitmapHeader->Width),		sizeof(BitmapHeader->Width));
	_read(FileHandle, &(BitmapHeader->Height),		sizeof(BitmapHeader->Height));
	_read(FileHandle, &(BitmapHeader->Planes),		sizeof(BitmapHeader->Planes));
	_read(FileHandle, &(BitmapHeader->BitCount),		sizeof(BitmapHeader->BitCount));
	_read(FileHandle, &(BitmapHeader->Compression),		sizeof(BitmapHeader->Compression));
	_read(FileHandle, &(BitmapHeader->SizeImage),		sizeof(BitmapHeader->SizeImage));
	_read(FileHandle, &(BitmapHeader->XPelsPerMeter),	sizeof(BitmapHeader->XPelsPerMeter));
	_read(FileHandle, &(BitmapHeader->YPelsPerMeter),	sizeof(BitmapHeader->YPelsPerMeter));
	_read(FileHandle, &(BitmapHeader->ClrUsed),		sizeof(BitmapHeader->ClrUsed));
	_read(FileHandle, &(BitmapHeader->ClrImportant),	sizeof(BitmapHeader->ClrImportant));
}

RGBH * CompletePixels(CUSTOMBITMAPHEADER *BitmapHeader, int FileHandle)
{
	RGBH *Buffer = (RGBH *)malloc(BitmapHeader->SizeImage);

	printf("Requesting:\t%ld Bytes\n", BitmapHeader->SizeImage);
	printf("Received:\t%ld Bytes\n", _read(FileHandle, Buffer, BitmapHeader->SizeImage));
	printf("\nReceiving Image Data: ");

	if(_eof(FileHandle) == false)
	{
		printf("Failed\n");
		free(Buffer);
		Buffer = NULL;
	}
	else
	{
		printf("Succeeded\n");
		_close(FileHandle);
	}

	return Buffer;
}

void DisplayHeader(CUSTOMBITMAPHEADER *BitmapHeader, FILE *Outstream)
{
	fprintf(Outstream, "\n\n");
	fprintf(Outstream, "Type:\t\t%hd\n", BitmapHeader->Type);
	fprintf(Outstream, "Size:\t\t%ld\n", BitmapHeader->Size);
	fprintf(Outstream, "Reserved1:\t%hd\n", BitmapHeader->Reserved1);
	fprintf(Outstream, "Reserved2:\t%hd\n", BitmapHeader->Reserved2);
	fprintf(Outstream, "OffBits:\t%ld\n", BitmapHeader->OffBits);
	fprintf(Outstream, "Size:\t\t%ld\n", BitmapHeader->RemainingSize);
	fprintf(Outstream, "Width:\t\t%ld\n", BitmapHeader->Width);
	fprintf(Outstream, "Height:\t\t%ld\n", BitmapHeader->Height);
	fprintf(Outstream, "Planes:\t\t%hd\n", BitmapHeader->Planes);
	fprintf(Outstream, "BitCount:\t%hd\n", BitmapHeader->BitCount);
	fprintf(Outstream, "Compression:\t%ld\n", BitmapHeader->Compression);
	fprintf(Outstream, "SizeImage:\t%ld\n", BitmapHeader->SizeImage);
	fprintf(Outstream, "XPelsPerMeter:\t%ld\n", BitmapHeader->XPelsPerMeter);
	fprintf(Outstream, "YPelsPerMeter:\t%ld\n", BitmapHeader->YPelsPerMeter);
	fprintf(Outstream, "ClrUsed:\t%ld\n", BitmapHeader->ClrUsed);
	fprintf(Outstream, "ClrImportant:\t%ld\n", BitmapHeader->ClrImportant);
	fprintf(Outstream, "\n\n");
}

void DisplayPixels(CUSTOMBITMAPHEADER *BitmapHeader, RGBH *Buffer, FILE *Outstream)
{
	fprintf(Outstream, "Pixel Information:\n");
	int I = 0;
	for(unsigned int Y = 0; Y < BitmapHeader->Height; Y++)
	{
		for(unsigned int X = 0; X < BitmapHeader->Width; X++)
		{
			printf("%ld %ld %ld %ld | ", Buffer[I].R, Buffer[I].G, Buffer[I].B, Buffer[I].H);
			I++;
		}
		printf("\n");
	}
}
With output:
Enter Input Path: c:\2.bmp

Opening File: Succeeded
Requesting: 16 Bytes
Received: 16 Bytes

Receiving Image Data: Succeeded


Type: 19778
Size: 70
Reserved1: 0
Reserved2: 0
OffBits: 54
Size: 40
Width: 2
Height: 2
Planes: 1
BitCount: 24
Compression: 0
SizeImage: 16
XPelsPerMeter: 0
YPelsPerMeter: 0
ClrUsed: 0
ClrImportant: 0


Pixel Information:
192 192 192 192 | 192 192 0 0 |
192 192 192 192 | 192 192 0 0 |


Press any key to continue
Note: I'm using a 2x2 Bitmap with all RGB(192, 192, 192) pixels.

Firstly, I tried to use a single _read():
_read(FileHandle, &BitmapHeader, sizeof(BitmapHeader));
However, that gave me some pretty crazy results when it came to displaying the header information. It seems it must be read in variable by variable. Have you gotten your Bitmap Loader working with just _read() line?

I found that _read() and fread() are both accomplishing the same thing, under Binary or just standard ASCII mode.

Using the RGBH struct however HAS significantly improved my output.

This may or may not be a good time to mention I'm using a 24-Bit BMP, could some of the problems be arising from this do you think?