
<p>M<em>ånga skulle säkert vilja ge bort några år av sitt liv för en seger i Prix d´Amérique. Mer tydligt än så går det knappast att uttrycka loppets storhet.</em></p>



<p>Orden är Sören Nordins! Han var den första svensk som fick stå som segrare i Europas mest välkända travlöpning. Året var 1950 och hästen amerikanske Scotch Fez.</p>



<p>– Mitt definitiva genombrott, konstaterade Sören Nordin efter triumfen.</p>



<p>Om Prix d&#8217;Amérique finns det mycket att säga. För blågul del har det blivit tio triumfer för tränare/kuskar på den svarta kolstybben.</p>



<h2 class="wp-block-heading">Pd’A-vinnare med svensk kusk eller tränare</h2>



<p><em>År, vinnare (far) – Kusk – Tränare</em></p>



<ul class="wp-block-list">
<li>1950 <strong>Scotch Fez</strong> (e. Scotland) – Sören Nordin – Sören Nordin</li>



<li>1973 <strong>Dart Hanover</strong> (e. Hoot Mon) – Berndt Lindstedt – William Casoli</li>



<li>1993 <strong>Queen L.</strong> (e. Crowntron) – Stig H Johansson – Stig H Johansson</li>



<li>1995 <strong>Ina Scot</strong> (e. Allen Hanover) – Helen A Johansson – Kjell P Dahlström</li>



<li>1999 <strong>Moni Maker</strong> (e. Speedy Crown) – Jean Michel Bazire – Jimmy Takter</li>



<li>2006 <strong>Gigant Neo</strong> (e. Super Arnie) – Dominik Locqueneux – Stefan Melander</li>



<li>2014 <strong>Maharajah</strong> (e. Viking Kronos) – Örjan Kihlström – Stefan Hultman</li>



<li>2018 <strong>Readly Express</strong> (e. Ready Cash) – Björn Goop – Timo Nurmos</li>



<li>2020 <strong>Face Time Bourbon</strong> (e. Ready Cash) – Björn Goop – Sebastien Guarato</li>



<li>2021 <strong>Face Time Bourbon</strong> (e. Ready Cash) – Björn Goop – Sebastien Guarato</li>
</ul>



<p>Tre av de svensktränade vinnarna har vunnit på den gamla banan – lades om våren 1993 – och först ut var Scotch Fez. Han följdes av Dart Hanover 1973 och Queen L. 1993.</p>



<p>– Fem dagar innan Prix d&#8217;Amérique skulle avgöras såg jag Vincennes-banan för första gången i mitt liv och det blev verkligen en chock. Här fick jag se ett kolstybbestråk på två kilometer som gick backe upp och backe ned.</p>



<p>Sören Nordin – vetgirig som få – ville förstås ta reda på höjdskillnaderna på banan, men varken sekretariatet, banmästaren eller de franska tränarna kunde ge ett exakt besked. Sju år efter segern med Scotch Fez – när Smaragd skulle tävla på Vincennes – lyckades Sören Nordin få låna ett avvägningsinstrument.</p>



<p>Från högsta punkten till den lägsta sänker sig banan tolv meter och trettio centimeter! Upploppet sjunker två meter på drygt tvåhundra, och i den stora nerförsbacken skjuter siffrorna raskt i höjden. På femhundra meter sänker sig banan tio meter och trettio centimeter! Distansen i Prix d&#8217;Amérique är 2.600 meter med start på anloppsbanan och från denna punkt till banans högsta ställe är stigningen 7,5 meter.</p>



<p>– Det är kalla siffror, men vill ni ha ett bättre begrepp om vad en travare får uträtta i ett Prix d&#8217;Amérique så tänk er att han först skall rusa 2,5 trappa i ett modernt hyreshus, sedan fyra trappor ned och så fyra trappor upp igen för att avsluta med en dryg halv trappa ner igen, beskriver Sören Nordin i boken &#8221;Spänn banden&#8221; om Vincennes dåtida bana.</p>


<div class="factbox left ">
<div class="insidefactbox">
<div class="overflow">
<div class="height">
<div class="padding">
<div class="factvinjett">Fakta</div>
<h3 class="title">
									Scotch Fez:								</h3>
<div class="content">
<p>Hingst född 1943 e. Scotland-High Noon e. Protector.<br /><strong>Ägare:</strong> Einar Engblad, Göteborg.<br /><strong>Uppfödare:</strong> Harkness Edwards, Kentucky.<br /><strong>Tränare i Sverige:</strong> Algot Scott och Sören Nordin.<br /><strong>Resultat:</strong> 52 st: 25-12-5.<br /><strong>Rekord:</strong> 1.17,6k.<br /><strong>Prissumma:</strong> 116.975 kr.<br /><strong>Större segrar:</strong> E.H. Harriman Challenge Trophy 1945, Färjestads Jubileumslopp 1947-1948, Internationellt heatlopp (Amager) 1948, Prix d&#8217;Amérique 1950, Skånelöpning, Åby Stora Pris 1949, Århus Jubileumslopp 1948.<br /><strong>Noterat:</strong> verkade som avelshingst både i Sverige och Holland. I Sverige registrerades 195 avkommor och i Holland – dit han exporterades 1960 – fick han 164 ättlingar.</p>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>
</p></div>



<p>Scotch Fez började sin karriär på andra sidan Atlanten. Han tävlade i den amerikanska unghästcirkusen och startade nästan uteslutande på 800-metersbanor. Han såldes till Sverige hösten 1946 via den danske hästsportmannen Henry Larsen – boende i New York – och köpare var tapetfabrikören Einar Engblad.</p>



<p>Vid samma tillfälle förvärvades också Whitney Hanover, vilken följde med som &#8221;resesällskap&#8221; till Scotch Fez till Paris. Veckan efter Scotch Fez bragd slutade han tvåa i Prix de Belgique bakom Prix d&#8217;Amérique-trean Volontaire.</p>



<p>Scotch Fez började sin karriär i Sverige hos Algot Scott på Åby och tävlade med framgång, men på våren 1949 beslutade ägaren Einar Engblad att flytta sina hästar till Sören Nordin.</p>



<p>Bitvis hade Scotch Fez problem med sin aktion – något som Sören Nordin rättade till som den mästare han var – och framgångarna lät inte vänta på sig. Segern i Åby Stora Pris i juni 1949 följdes upp med seger i Amagers heatlopp, där han noterade 1.18,0, 1.18,8 och 1.18,9, vilket betydde europeiskt rekord alla kategorier för tre heats!</p>



<p>Scotch Fez fortsatte fira framgångar och efter segern i stayerprovet Skånelöpning i snöslask och regn, vilket förvandlade Jägersrobanan till rena lervällingen visade också Scotch Fez att han inte bara besatt en enastående snabbhet utan också en osedvanlig styrka.</p>



<p>Ägaren Einar Engblad hade länge burit på en dröm. En dröm som han släppte fram i ljuset. Han ville starta Scotch Fez i Prix d&#8217;Amérique.</p>



<p>– Först efteråt förstod jag vilket vågspel vi gav oss in på.</p>



<p>En gång tidigare hade en svensktränad travare provat Prix d&#8217;Amérique. Harper Hanover ansågs med blågula ögon kapabel till nästan vad som helst. I Prix d&#8217;Amérique 1939 blev det dock startgalopp.</p>



<p>Samma öde var nära att gå Scotch Fez och Sören Nordin till mötes. Han skriver själv om starten i Prix d&#8217;Amérique i sin första memoarbok:</p>



<p><em>&#8221;Jag hann precis vända upp i den obeskrivliga trängseln och sätta fart mot främre bandet då den tjocka, gula gummisnodden släpptes. Skotten var sprudlande pigg, alldeles vild av löpsugenhet och högg i för allt vad han var värd. Och högg i galopp!!! Ett halvt års arbete och tusentals kronor bortkastade på en tiondels sekund. Allt var förlorat. Skottens chanser borta, Gunnar Berndtsson ruinerad, risken att ägaren dog av hjärtslag&#8230; Den var det svartaste ögonblicket i mitt liv.&#8221;</em></p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p>Jag ser Buck komma rusande som ett expresståg&#8230;Nu är det kokta fläsket stekt!</p>
</blockquote>



<p>Innan Sören Nordin själv visste ordet av hade Scotch Fez hittat rätt gångart.</p>



<p><em>&#8221;Det var ett under, så frisk som han var, och jag skulle vilja se den häst som gjort det i samma situation.&#8221;</em></p>



<p>Nu ordnade saken upp sig relativt hyggligt och Scotch Fez serverades en resa som trea på innerspår. Framför sig hade han Grand Parade, Sylvére, Sammy och Banco III, medan de två hästarna som Sören Nordin hade störst respekt för – Buck och Scotch Thistle – var längre ner i fältet efter dåliga starter.</p>



<figure class="wp-block-gallery has-nested-images columns-3 is-cropped wp-block-gallery-2 is-layout-flex wp-block-gallery-is-layout-flex">
<figure class="wp-block-image size-large"><img data-id="514" src="https://sulkysport.se/wp-content/uploads/2017/01/scotchfezprispdatz-1024x882.jpg" alt="" class="wp-image-514"/></figure>



<figure class="wp-block-image size-large"><img data-id="515" src="https://sulkysport.se/wp-content/uploads/2017/01/scotchfezmal-1024x562.jpg" alt="" class="wp-image-515"/></figure>



<figure class="wp-block-image size-large"><img data-id="517" src="https://sulkysport.se/wp-content/uploads/2017/01/tavlorscotchfeztz-1024x629.jpg" alt="" class="wp-image-517"/></figure>



<figure class="wp-block-image size-large"><img data-id="518" src="https://sulkysport.se/wp-content/uploads/2017/01/scotchfezpda2-1024x547.jpg" alt="" class="wp-image-518"/></figure>



<figure class="wp-block-image size-large"><img data-id="520" src="https://sulkysport.se/wp-content/uploads/2017/01/scotchfezheat-e1484600321866-1024x609.jpg" alt="" class="wp-image-520"/></figure>



<figure class="wp-block-image size-large"><img data-id="521" src="https://sulkysport.se/wp-content/uploads/2017/01/scotchfezpda-1024x621.jpg" alt="" class="wp-image-521"/></figure>



<figure class="wp-block-image size-large"><img data-id="522" src="https://sulkysport.se/wp-content/uploads/2017/01/scotchfezauktion-1024x610.jpg" alt="" class="wp-image-522"/></figure>
</figure>



<p><em>&#8221;Endast niohundra meter återstår, och täthästarna verkar allt tröttare. Italienaren smackar och driver och jagar på Scotch Thistle. Då förvärras plötsligt situationen. Jag ser Buck komma rusande som ett expresståg utanför den klunga av konkurrenter jag har snett bakom mig. Nu är det kokta fläsket stekt!&#8221;</em></p>



<p>Sören Nordin inser faran, att Scotch Fez kan bli instängd.</p>



<p><em>&#8221;Skulle jag våga en utbrytning och riskera att bli diskad för trängning? Mina vänner hade satt sin sista skjorta på mig.&#8221;</em></p>



<p>Sören Nordin valde inte att agera &#8221;söndagsskolgosse&#8221; utan gled långsamt ut med Scotch Fez och skaffade sig det utrymme som krävdes för att få fritt spelrum.</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p>Hellre fick dom kalla Sören Nordin för buse och knöl än han svek sina vänner</p>
</blockquote>



<p>Vid ingången till sista sväng hade Scotch Fez övertagit ledningen och inne på upploppet möttes av 40.000-50.000 vrålande fransmän. Hemmafavoriten Buck hade nämligen hittat förnyade krafter och tog upp jakten på Scotch Fez.</p>



<p><em>&#8221;Jag hade tydligen gjort mig skyldig till en allvarlig underskattning av hans förmåga.&#8221;</em></p>



<p>Sören Nordin påminde Scotch Fez om stundens allvar:</p>



<p><em>&#8221;Han tände direkt och formligen vräkte sig framåt, men ändå märkte jag hur Buck närmade sig mer och mer. Hundra meter före mål var jag ganska säker på att slaget var förlorat. Men jag hade inte en tanke på att ge upp. Trots det hårda loppet, trots den rasande pressen visade inte heller Skotten någon ansats till att ge tappt. Han bet i som aldrig förr, lade ner hela sin energi i varje steg, tog ut vartenda uns av styrka i sina kraftiga muskler. En kort bit före mål skar det ihop sig alldeles, inte för Skotten men för Buck.&#8221;</em></p>



<figure class="wp-block-image aligncenter"><a href="https://sulkysport.se/wp-content/uploads/2017/01/resultatpda.jpg"><img src="https://sulkysport.se/wp-content/uploads/2017/01/resultatpda-807x1024.jpg" alt="" class="wp-image-516"/></a></figure>



<p>Sören Nordin satt blickstilla i sulkyn när Scotch Fez tog de sista snabba stegen över mållinjen.</p>



<p><em>&#8221;Jag trodde inte själv att det var sant. Drömmen var verklighet. Scotch Fez hade vunnit Prix d&#8217;Amérique. Utan överdrift var det den lyckligaste stunden i mitt liv.&#8221;</em></p>



<p>Förstapriset uppgick till 2,5 miljoner francs, vilket motsvarade 37.500 kronor. Ägaren Einar Engblad och hans &#8221;kompanjon&#8221; Gunnar Berndtsson kunde dessutom glädja sig åt oddset 7,51. De hade satsat 8.000 respektive 4.000 kronor vinnare på Scotch Fez.</p>



<p>Efter loppet fick Einar Engblad ett bud på 150.000 kronor, men Scotch Fez var inte till salu för något pris.</p>



<p>Efter Prix d&#8217;Amérique skulle inte Scotch Fez starta mer. Han sattes i avel och skulle användas till ett begränsat antal ston (sex avkommor föddes 1951), men åtta månader senare togs karriären upp på nytt. Fyra ytterligare starter blev det innan tävlingsskorna lades på hyllan för alltid!</p>



<figure class="wp-block-image aligncenter"><a href="https://sulkysport.se/wp-content/uploads/2017/01/stamtavlafrslag.jpg"><img src="https://sulkysport.se/wp-content/uploads/2017/01/stamtavlafrslag.jpg" alt="" class="wp-image-596"/></a></figure>
