
<p class="has-drop-cap">1Karriärens största seger togs på hemmabanan Jägersro i Svensk Uppfödningslöpning förra året och den senaste storsegern i korta E3-finalen på Romme i augusti. Ikväll är Tomas Malmqvists treårige ämne <strong>Fiftyfour</strong> (e. Fourth Dimension) tillbaka på hemmaplan, men spårlottningsdatorn har inte varit nådig med stjärnhästen som brottas med spår tolv bakom bilen i ett försök till Breeders Crown.</p>



<p>Unghästarna står i fokus på båda kvällens banor i Sverige och på <strong>Jägersro</strong> (första start 18.00) väntar fyra uttagningslopp till Breeders Crown, där förutom Fiftyfour flera andra starka namn dyker upp. Som jämngamla italienska stoet <strong>Ester Degli Dei</strong> (e. Maharajah). Paul Hagoort tränar stoet som står över italienska Stoderbyt för att säkra en plats i svenska Breeders Crown-semifinalerna. Ester Degli Dei slog hingstarna i finalen av Breeders Course på Åbergskvällen i slutet av juli och har vunnit sex av sju starter i karriären.</p>



<p>På fyraåringssidan märks bland stona fjolårets Oaks-tvåa <strong>Aurelia Express</strong> (e. Readly Express), som varit finalist i både Stochampionatet och Derbystoet, medan färske Derbytrean <strong>Love Keeper</strong> (e. Propulsion) har de tyngsta meriterna bland de fyraåriga hingstarna och valackerna.</p>



<p>Jägersro står som värd för den sjätte av nio försöksomgångar i Breeders Crown och här vinnarna i årets försök:</p>



<ul class="wp-block-list">
<li><strong><em>Treåriga h/v:</em></strong> Immortal Doc (e. Brillantissime), Global Etalon (e. Brillantissime), Katzenjammer (e. Fourth Dimension), Fiftyfour (e. Fourth Dimension), S.G.Dracarys (e. Bold Eagle)</li>



<li><strong><em>Treåriga ston: </em></strong>Kitty Hawk (e. Fourth Dimension), Coral Coger (e. Ken Warkentin), Larah Westwood (e. The Bank), Global Election (e. Tactical Landing), Kinglet Bird (e. Nuncio)</li>



<li><strong><em>Fyraåriga h/v: </em></strong>Hustle Rain (e. Raja Mirchi), H.C.’s Crazy Horse (e. S.J.’s Caviar), Game Brodde (e. S.J.’s Caviar), Make It Schermer (e. Propulsion), Dancer Brodde (e. Bold Eagle)</li>



<li><strong><em>Fyraåriga ston: </em></strong>Decision Maker (e. Nuncio), Queen Belina (e. Nuncio), Ninepoints Birdie (e. Bold Eagle), Luxury River (e. Muscle Hill), Mellby Korall (e. Maharajah)</li>
</ul>



<p>Redan i morgon i<strong> Boden </strong>är det dags för BC-försök igen och sedan avslutas uttagningsloppen på <strong>Axevalla</strong> (17/10) och <strong>Bollnäs</strong> (20/10). Semifinalerna avgörs på <strong>Solvalla</strong> (5 november) och finalen på <strong>Sundbyholm </strong>(18 november).</p>



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



<p class="has-drop-cap">2 Ett nytt lopp, eller rättare sagt två, har premiär på <strong>Solvalla</strong> (första start 18.15) ikväll. Det handlar om Höstfavoriten för treåringar som klivit in i huvudstadsbanans Kriterieserie för hästar anmälda till Svenskt Travkriterium och Oaks. Precis som i de tidigare loppen i serien – Vinterfavoriten (för tvååringar), Vårfavoriten och Sommarfavoriten – bjuds 200.000 kronor vardera i förstapris för vinnarna i hingst- och stoklassen. </p>



<p>Med 18 dagar kvar till Kriterie- och Oakskval på Solvalla, så har också de båda treåringsloppen lockat flera starka namn. </p>



<p>På hingstsidan märks Roger Walmanns <strong>S.G.Dracarys</strong> (e. Bold Eagle) som varit tvåa i långa E3 och trea i den korta upplagan, samt Fredrik Perssons talang <strong>Frank S.H.</strong> (e. Fourth Dimension), som närmast kommer från andraplatsen i korta E3. Vinnaren i den finalen startar som bekant i Breeders Crown-försök på Jägersro ikväll, nämligen Fiftyfour.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/s.g.dracarysokhadamweb-617x333.jpg" alt="" class="wp-image-464426"/><figcaption class="wp-element-caption">S.G.Dracarys tillsammans med Örjan Kihlström. Foto Adam Ström/StallTZ.se.</figcaption></figure>



<p>E3-meriter har också de mest meriterade treåringarna i stoavdelningen, Mattias Djuses duo <strong>Knickers Sisu </strong>(e. Southwind Frank) och <strong>Larah Westwood</strong> (e. The Bank), som varit tvåa i varsin E3-final. Dubbla E3-finaler har också Daniel Redéns tämligen färska nyförvärv <strong>Kinglet Bird</strong> (e. Nuncio), som slutat femma och trea i finalerna.</p>



<p>Solvalla delar kvällens expresstrav med Jägersro och Sulkysports tips publiceras som vanligt kl 12.00 idag.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/09/13v86.pdf" class="">Här kan du ta del av dagens startlistor till tävlingarna.</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-09-13_40_1" class="">Sulkysport Lilla V86 – 15 andelar á 75 kr/styck</a></p>



<p><a href="https://www.atg.se/andelskungen/spel/206235_V86_2023-09-13_40_1" class="">Sulkysport Stora V86 – 15 andelar á 250 kr/styck</a></p>



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



<p class="has-drop-cap">3Dagens högst doterade travlopp på europeisk mark avgörs i franska <strong>Angers </strong>(första start kl. 13.50).<br>Vi har kommit fram till årets tionde etapp av den rikstäckande löpningsserien Grand National du Trot (€90.000) och där jagar Sébastien Guarato-tränade <strong>Horace du Goutier</strong> (e. Ready Cash) sin femte GNT-seger för året i lag med Hugues Monthule.</p>



<p>Loppet liksom hela tävlingsdagen avgörs utan blågula inslag, men de går istället att finna i <strong>Reims</strong> (första start kl. 16.27).<br>I Grand Prix de l&#8217;Hippodrome Reims (€35.000) tävlar såväl Johan Untersteiners <strong>Racing Ribb</strong> (e. Raja Mirchi) som Tomas Malmqvists<strong> Digital Dominance </strong>(e. Super Photo Kosmos) och den sistnämnde tävlar även med <strong>El Messie Joroco</strong> (e. Laetenter Diem) i lärlingsloppet Prix de l&#8217;Hippodrome de Vittel (€22.000).</p>



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



<p class="has-drop-cap">4Fem, sju respektive sex hästar har startat i de tre första uttagningsloppen i Breeders Course för tvååringar, där de tre främsta gått vidare till finalen på Jägersro den 4 oktober med 700.000 kronor till vinnaren över sprinterdistans.</p>



<p>Ikväll på finalbanan ska de tre sista finalplatserna delas ut och intresset var minst sagt stort. Hela 16 tvååringar anmäldes till kvalet, vilket innebär att det blir två försök. Till skillnad mot de redan avgjorda uttagningsloppen innebär det att bara vinnaren och den högst rankade tvåan i kvällens två försök får finalplats, att jämföra med sammanlagt 18 startande tvååringar och nio finalplatser i de tre första försöken.</p>



<p>En av deltagarna i kvalen har redan ordnat plats i finalen, norske <strong>Gimmefive Ravin </strong>(e. Ken Warkentin), som tillsammans med sin tränare Erlend Rennesvik slutade tvåa i uttagningsloppet på Solvalla.</p>



<p><strong>Försöksvinnare i Breeders Course för tvååringar:</strong></p>



<ul class="wp-block-list">
<li><strong>Feldenkrais Pal </strong>(e. Trixton-Tuscania Pal) – Micha Brouwer – 1.14,5a</li>



<li><strong>Chapter One</strong> (e. Chapter Seven-Etta Am) – Fredrik Wallin – 1.16,9a</li>



<li><strong>Fiammetta Bar</strong> (e. Ringostarr Treb-Lusinga) – Magnus Dahlén – 1.15,4a</li>
</ul>



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



<p class="has-drop-cap">5Håkan K Persson har räknat hem tre nyförvärv till sitt stall. Två av dem ägs av storhästägaren Karin Walter-Mommert och bland dem sticker <strong>Comand and Conquer S</strong>, 1.15,5am/217.415 kr, ut lite extra.</p>



<figure class="wp-block-image alignright size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2017/07/hkankpersson-617x333.jpg" alt="" class="wp-image-9418"/><figcaption class="wp-element-caption">Håkan K Persson. Leif Norberg ALN</figcaption></figure>



<p>Tactical Landing-sonen kommer närmast från en andraplats bakom Zoom Diamant i finalen av Dreijährigen-Serie 2023 (€50.000) i Berlin och har vunnit en av fem starter så här långt i karriären.</p>



<p>Wolfgang Nimczyk har tidigare tränat hingsten och han har även haft den tyskfödda Love You-dottern <strong>Chelsea</strong>, 1.14,2ak/23.432 kr, i sin vård, medan Perssons tredje nyförvärv <strong>Rex Tile </strong>(e. Father Patrick), 1.13,3ak/149.890 kr, anslutit från Preben Söviks stall.</p>



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



<p class="has-drop-cap">6En svenskfödd häst syns bland deltagarna när det är dags för årets hittills högst doterade tvååringslopp i Finland.</p>



<p>Det handlar om Junnustartti final (€16.500) där Pekka Korpi bidrar med Express Duo-dottern <strong>Arctic Estelle</strong> som vann tävlingsdebuten i Lahti på 1.17,9a/2.140 meter.</p>



<p><strong>Startlista Junnustartti final </strong><br><em>2.120 meter autostart, förstapris: 7.500 dollar</em></p>



<ol class="wp-block-list">
<li>Levitating (e. Zola Boko) – Tommi Kylliäinen (Jonny Länsimäki)</li>



<li>Explosive Combo (e. Saxo de Vandel) – Kari Venäläinen (Pekka Korpi)</li>



<li>Arctic Emerald (e. Express Duo) – Pekka Korpi</li>



<li>Ava di Augustina (e. Express Duo) – Hannu-Pekka Korpi</li>



<li>Gallinago Snipes (e. Muscle Mass) – Jussi Tomperi</li>



<li>Arctic Estelle (e. Express Duo) – Santtu Raitala (Pekka Korpi)</li>



<li>Xaman Kemp (e. Trixton) – Ari Moilanen (Markku Nieminen)</li>



<li>Top Hit (e. Toast of Lindy) – Terno Grönstrand</li>



<li>Enrico Combo (e. Maharajah) – Iikka Korpi (Pekka Korpi)</li>



<li>Mas Indy (e. The Bosses Lindy) – Jarmo Saarela (Timo Korvenheimo)</li>



<li>Idontknow (e. Brad de Veluwe) – Hannu Torvinen (Marjo Lindström)</li>



<li>Parttime Priest (e. Like di Poggio) – Patri Filatoff (Rami Hiltunen)</li>
</ol>



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



<p class="has-drop-cap">7 Igår inleddes Europas största unghästauktion i Caen. Under åtta dagar ska det säljas ettåringar och katalogen innehåller 950 hästar. Dyrast under öppningsdagen blev <strong>Melius Avis</strong> (e. Bold Eagle-Dirae Avis) och han klubbades för 75.000 euro. Hingsten köptes av trion Jean-Marc Chaineux, Ecurie Mexique Ranch och Benjamin Hedin.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/09/skarmavbild20230912kl.19.10.09-617x456.jpg" alt="" class="wp-image-495510"/><figcaption class="wp-element-caption">Melius Avis. Foto: privat</figcaption></figure>



<p>Modern <strong>Dirae Avis</strong> (e. Ganymede), 1.13,7/€123.650, har sin första avkomma i Melius Avis. Själv är Dirae Avis undan <strong>Magna Avis</strong> (e. Tenor de Baune), 1.14,5/€65.110, vilken också lämnat <strong>Ave Avis</strong> (e. Kesaco Phedo), 1.10,5/€911.870, och <strong>Ter Avis</strong> (e. Ganymede), 1.12,8/€140.480.</p>



<p>Jean-Marc Chaineux var också inblandad i den näst dyraste ettåringen och tillsammans med Philipe Beine och Olivier Derock ropades hingsten <strong>Mojito Céné</strong> (e. Alto de Viette) in för 42.000 euro. Han är undan<strong> Dynamite du Boulay</strong> (e. Defi d’Aunou), 1.13,8/€91.310, vilken har tre avkommor i startbar ålder, varav två visat sig på tävlingsbanan. Bäst ifrån sig har fyraåriga <strong>Johanite</strong> (e. Captain Sparrow), 1.15,4/€19.290, gjort även om hon är segerlös efter 19 starter.</p>



<p><a href="https://ventes-caen-trot.com/catalogue-resultats-ventes-2023/" target="_blank" rel="noreferrer noopener">Auktionsresultaten hittar ni här.</a></p>
