
<p class="has-drop-cap">1Ett rejält test över lång distans inför stundande Derbykval på Jägersro. Eskilstunas Fyraåringstest har körts sedan 1976, då <strong>Expresso</strong> (e. Express Rodney) och Sven-Gunnar Andersson vann och ser många starka vinnare i historien.</p>



<p>Fem av dessa har gått vidare och vunnit Svenskt Travderby en dryg månad senare. Redan tredje året, 1978, skedde det för första gången när Olle Lindqvist-tränade <strong>Spinoon</strong> (e. Speedy Spin) gick den vägen. 1987 valde Anders Lindqvist samma matchningsplan med <strong>Atom Knight</strong> (e. Janies Knight), både 1998 och 1999 tog <strong>Jolly Rocket</strong> (e. Atas Rocket) och Per Lennartsson, samt <strong>Victory Tilly</strong> (e. Quick Pay) och Stig H Johansson hem båda loppen.</p>



<p>På 2000-talet har det däremot bara hänt en gång. <strong>Readly Express</strong> (e. Ready Cash) vann först i Eskilstuna på löpningsrekordet 1.12,1/2.640 meter och behövde sedan &#8221;bara&#8221; trava 1.12,7a för att vinna Derbyt på Jägersro. Readly Express segertid i Fyraåringstestet pressades med en tiondel av fjolårets vinnare: Kentucky River (e. Father Patrick) och Per Nordström.</p>



<p>Årets upplaga då? Döljer det sig en Derbyvinnare bland de åtta svenskfödda fyraåringar som möter två italienska travare? Ja, omöjligt är det inte. Årets upplaga håller hög klass med tvååringsstjärnan och Kungapokalstvåan <strong>Tetrick Wania</strong> (e. Muscle Hill) och årets treåring i Sverige förra året, <strong>Bedazzled Sox</strong> (e. Brillantissime), som även slutade trea i Kungapokalen.</p>



<p>Spårvinnare blev Conrad Lugauer som drog spår fyra för Tetrick Wania, medan Roger Walmanns Bedazzled Sox tvingas inleda från bakspår.</p>



<h2 class="wp-block-heading">Snabbaste vinnarna av Eskilstunas Fyraåringstest</h2>



<p><em>År, häst (far) – Kusk (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2022 Kentucky River (e. Father Patrick) – Per Nordström – 1.12,0a</li>



<li>2016 Readly Express (e. Ready Cash) – Jorma Kontio (Timo Nurmos) – 1.12,1a</li>



<li>2020 Ecurie D. (e. Infinitif) – Björn Goop (Frode Hamre) – 1.12,7a</li>



<li>2013 Indigious (e. Prodigious) – Erik Adielsson (Stig H Johansson) – 1.12,8a</li>



<li>2014 Archangel Am (e. Going Kronos) – Lutfi Kolgjini – 1.12,9a</li>



<li>2018 Very Kronos (e. Ready Cash) – Erik Adielsson (Svante Båth) – 1.13,4a</li>
</ul>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">2Eskilstuna (första start 17.45) bjuder på en fullmatad onsdagkväll med STL-klasser. Gulddivisionen har namngetts en av banans stora tränarnamn genom åren, Håkan ”Hockey” Eriksson, och har samlat ett spännande sällskap.</p>



<p>Hästen som sticker ut är Timo Nurmos-tränade <strong>Brother Bill </strong>(e. From Above), som efter att ha travat 1.09,1ak i årsdebuten på Solvalla bjöds in till Elitloppet, men varken övervakningsstall över natten eller högljudd publik verkade vara valackens melodi. Han presterade under pari i Elitloppsförsöket och Nurmos tvingades sedan stryka hästen från den tilltänkta starten i Jämtlands Stora Pris på grund av dåliga blodvärden.</p>



<p>Nu har hästen laddat om och är redo för första starten på nästan två månader. Förra året hade han också en stökig inledning på säsongen på våren och början av sommaren, innan det lossnade rejält med start med andraplatsen i Årjängs Stora Sprinterlopp. Det börjar bli Brother Bills tid nu helt enkelt!</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/07/19v86.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till V86-omgången i Eskilstuna.</a></p>



<p><em>Vill du spela V86 tillsammans med Sulkysport kan du välja mellan följande alternativ:</em></p>



<p><a href="https://www.atg.se/andelskungen/spel/206233_V86_2023-07-19_14_4" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V86 – 15 andelar á 75 kr/styck</a></p>



<p><a rel="noreferrer noopener" href="https://www.atg.se/andelskungen/spel/206235_V86_2023-07-19_14_4" target="_blank">Sulkysport Stora V86 – 15 andelar á 250 kr/styck</a></p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">3 Parisbanan Enghien (första start 15.42) travar igång under seneftermiddagen och det finns fyra svensktränade hästar till start inom de åtta loppen.<br>Tomas Malmqvist startar en duo i form av <strong>Key Biscayne </strong>(e. Face Time Bourbon) som gör sadeldebut i Prix de la Place Dauphine (€46.000) och <strong>Jupiter</strong> (e. Goetmals Wood) som startar i Prix de la Place Rodin (€40.000).<br>I det sistnämnda loppet startar även Björn Goop <strong>Jack l&#8217;Eventreur</strong> (e. Oardo) och så syns Jörgen Westholm-tränade <strong>Kingpin</strong> i Prix de la Porte de Pantin (€40.000).</p>



<p>På tal om svenskar och Frankrike så släpar vi med resultatredovisningen från landsortstävlingar i söndags.<br>Tomas Malmqvist hade en toppdag med segrar på tre olika banor. <strong>Kobayashi</strong> (e. Face Time Bourbon) segrade i Prix Circuit de Cabourg (€18.000) i Deauville, <strong>Kosanostra</strong> (e. Express Jet) räknade hem Prix Sas Boutillet (€14.000) i La Roche och så vann <strong>Kelina Josselyn</strong> (e. Face Time Bourbon) Prix C.A.R. Audi-Royan Wolkswagen (€18.500) i Royan.</p>



<p>Björn Goop noterades i sin tur för en dubbel genom <strong>Keep Out</strong> (e. Dijon) som vann Prix Courtoise Automobile Suzuki (€12.500) i Abbeville och så vann <strong>Geoffrey d&#8217;Am</strong> (e.  Timoko) Prix Pere Dehon (€30.000) i La Capelle på 1.11,9a/1.800 meter.</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">4 Trav-Sveriges kortaste meeting drar igång idag – och avslutas i morgon. Blekingebanan i Karlshamn (först start 12.20) är unik på fler sätt, då publiken ser loppen från innerplan i Karlshamn.</p>



<p>Tvådagarsevenemangets största lopp är Tom Stenholm Memorial med 80.000 kronor till vinnaren. Tom Stenholm var tillsammans med sin fru Monica de stora eldsjälarna när den nya travbanan kom till och invigdes för 30 år sedan, den 8 augusti 1993. Tom Stenholm avled 2016.</p>



<figure class="wp-block-image aligncenter size-full"><img src="https://sulkysport.se/wp-content/uploads/2023/02/bravosabotage.jpg" alt="" class="wp-image-410520"/><figcaption class="wp-element-caption">Ola Samuelsson-tränade Bravo Sabotage dyker upp i Karlshamn. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Huvudloppet ut utskrivet som en spårtrappa över drygt tre varv på 800-metersbanan och mest meriterad är Ola Samuelsson-tränade<strong> Bravo Sabotage</strong> (e. From Above), som ska försöka lösa uppgiften från åttondespår bakom startbilen.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/07/230719.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till onsdagens tävlingar.</a></p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">5 Sprintermästar- och Kungapokalstvåan Rome Pays Off (e. Muscle Hill) gjorde årsdebut på på Hagmyren under gårdagslunchen, men trots att Daniel Wäjerstens sexåring kutade 1.12,8/2.180 meter var hingsten chanslös på segern!</p>



<p>Onekligen tuffa papper, men Reven Dejavu (e. Revenue) var helt enkelt för bra startande 20 meter före och vann loppet på 1.13,4 trots galopp.<br>Seger blev det däremot för Mattias Djuses <strong>Azrael R.B. </strong>(e. Tekno Odin) i ett ramlopp.<br>Femåringen är alltjämt ovetande om hur det känns att förlora travlopp efter att vunnit karriärens tredje start på 1.31,0/2.640 meter i lag med sin tränare.</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">6 Den fyraårige valacken <strong>Michel F.Boko </strong>(e. Southwind Frank) 1.14,6ak/176.090 kr har bytt regi, men blir kvar i Halmstadregionen.<br>I Rick Ebbinges regi segrade hästen direkt i Sverigedebuten i mitten av april, men därefter har hästen som bäst slutat fyra i två av de tre efterkommande starterna.<br>Nu blir det Johan Untersteiners uppgift att ta halvbrodern till 2014 års tyska derbytvåa <strong>Ewald F Boko </strong>(e. Super Arnie) 1.12,9/€86.133 till nästa nivå.</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">7 Den norska stjärnhästen <strong>Moni Viking </strong>(e. Maharajah) tvingas till ett kort uppehåll.<br>– Planen var egentligen att han skulle starta på Jägersro på tisdag, men Moni Viking har fått en smäll på griffelbenet och det ser ut att ha blivit ett brott. Ett griffelbensbrott är inte en så allvarlig skada då hästen inte behöver det benet, men tar likväl lite tid innan han kan starta igen, <a href="https://tgn.no/artikkel/skulle-opprinnelig-starte-tirsdag-men-na-er-han-satt-pa-sidelinjen-igjen/" target="_blank" rel="noreferrer noopener">säger ägaren Jan Lyng till TGN.no.</a></p>



<p>Att försvara titeln från fjolårssegern i Åby Stora Pris tycks med andra ord vara helt uteslutet för Maharajah-sonens del.</p>

Fokustema
Morgonsvepet
Läs senare
Varvar upp inför Derbyt
Om Eskilstunas klassiska fyraåringstest, Elitloppshäst i återkomst och norsk stjärnhäst som står skadad går bland annat att läsa i veckans tredje morgonsvep.
