
<p class="has-drop-cap wp-block-paragraph">1Första utrop klockan 17.00, budgivning från 08.00 och visning av ettåringarna med start 10.00. ASVT:s Next Generation Sale hålls på Sundbyholms travbana under två dagar och under den första dagen säljs nummer 1-142.</p>



<p class="wp-block-paragraph">I år har ASVT flyttat ”Kriterieauktionen” till Sundbyholmstravbana och det går att bjuda på hästarna både på plats och digitalt. <a href="https://menhammaronlinesales.se/auction/next-generation-sale-2023/?&#038;snabbval=only_ironed" target="_blank" rel="noreferrer noopener">Här hittar du hästarna som säljs.</a></p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/ettaringarna-pa-nya-auktionen/" target="_blank" rel="noreferrer noopener">Sulkysport har tidigare gjort en genomgång av auktionen och den hittar ni här.</a></p>



<p class="wp-block-paragraph"><strong>Följande hästar är strukna under första dagen: </strong>29 Höwings Eagle,<br>55 Fifth Avenue Trot, 62 Beat Garde, 81 Boutique Garde, 91 Baba Rum, 96 Baldan Garde, 98 Bower Garde, 101 Caribia W.F, 114 Bransbys Malte, 118 Lilla Långöra, 127 Marlon Brando Sisu, 139 Xanthis Kaliber.</p>



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



<p class="has-drop-cap wp-block-paragraph">2Två treåriga miljonston dyker upp i fredagens höjdare på svensk travmark, nämligen Dalatravet Rommes Treåringspris med 100.000 kronor till vinnaren på <strong>Romme</strong> (första start 18.00). Mattias Djuse plockar <strong>A Teaser </strong>(e. Flocki d’Aurcy) och <strong>Frustration</strong> (e. Fourth Dimension) i genrep till uttagningsloppen i Svenskt Trav-Oaks på Solvalla den 1 oktober.</p>



<p class="wp-block-paragraph">Frustration hade en lysande tvååringssäsong med andraplatser i Svensk Uppfödningslöpning och Svampen och i år har hon vunnit en avdelning i Margaretas Tidiga Unghästserie. Detta har även A Teaser lyckats med då hon slog till i en avdelning på Solvalla i maj, men den stora triumfen kom på just Rommetravet i mitten av augusti när A Teaser vann korta E3-finalen för ston på 1.10,9a/1.640 meter.</p>



<p class="wp-block-paragraph">Nu handlar det om medeldistans och en spårtrappa. Bland motståndarna finns Reijo Liljendahls kapable italienare <strong>Eclipse As</strong> (e. Nuncio), som vann Slaget Vid Axevalla Hed på Stochampionatsdagen i sin senaste start.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/bp6a1400-617x405.jpg" alt="" class="wp-image-474212"/><figcaption class="wp-element-caption">Reijo Liljendahl-tränade Eclipse As vid seger i Slaget vid Axevalla Hed. Foto Anton Gustavsson/SLA.</figcaption></figure>



<p class="wp-block-paragraph">På avdelningen ston – Daniel Redén sänder dit femåriga miljonärskan<strong> Faeza Zet</strong> (e. Ken Warkentin), som vunnit tio av livets 20 starter och nu körs av Magnus A Djuse för första gången.</p>



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



<p class="has-drop-cap wp-block-paragraph">3Romme delar kvällens expresstrav med Östersund (start 18.30), där elva ston gör upp i en spårtrappa i ett försök i Norrlands Elitserie, vars stofinal körs på Bergsåker den 11 november med 150.000 kronor till vinnaren.</p>



<p class="wp-block-paragraph">Hemmatränaren Per Linderoth har haft <strong>Young Mistress </strong>(e. Orlando Vici) i toppslag i sommar och det gav full utdelning när hon tillsammans med Niclas Hammarström vann Lasse Lindbergs Minne under Bergsåkers storhelg i slutet av augusti. Nu har hon – som rikast i kvällens försök – dragit spår åtta och möter bland annat Robert Berghs <strong>Carroty</strong> (e. Readly Express), som vunnit ett av de titigare försöken i Norrlands Elitserie.</p>



<p class="wp-block-paragraph">Fredagen inleds med lunchtävlingar på Åby (start 12.20), där två segervana fyraåringar som ännu inte kommit upp i sexsiffrig prissumma möts. Det handlar om Jerry Riordans italienare <strong>Diamante Geo</strong> (e. Ready Cash), som svek i Sverigedebuten efter fyra segrar och två andrapris på italiensk mark, samt Robert Berghs Hilda Zonett-son <strong>Allan Zonett</strong> (e. Maharajah), som inledde karriären med tre raka segrar. </p>



<p class="wp-block-paragraph">Nu startar de båda bredvid varandra bakom bilen i ett långlopp.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/09/230915.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till fredagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4Idag och i morgon avgörs &#8221;derbyrevanscher&#8221; i danska Ålborg (första start kl 15.45) och idag är det damerna som gör upp i en egen klass.</p>



<p class="wp-block-paragraph">Michael Lönborgs <strong>Harper</strong> (e. Broadway Hall) som vann Stoderbyt för två veckor sedan finns med bland de tolv hästarna som drabbar samman i strid om segerchecken på 75.000 danska kronor och loppet innehåller även två svenskfödda hästar i form av Jeppe Juels duo <strong>Cori Gauff</strong> (e. Trixton) och <strong>Hertz</strong> (e. Readly Express).</p>



<p class="wp-block-paragraph"><strong>Startlista Aalborg Hoppechampionat</strong><br><em>2.140 meter autostart, förstapris: 75.000 ddk</em></p>



<ol class="wp-block-list">
<li>Hazy Brogård (e. Wishing Stone) – Rene Kjaer (Mikael Poulsen)</li>



<li>Herina Sotto (e. Love You) – Bo Westergård</li>



<li>Helena D D (e. Orlando Vici) – Jeppe Rask</li>



<li>Hillary Kyvsgård (e. From Above U S) – Nicklas Korfitsen (Bo Westergård)</li>



<li>Cori Gauff (e. Tixton) – Jeppe Juel</li>



<li>Harper (e. Broadway Hall) – Michael Lönborg</li>



<li>Hashtag Ostedantik (e. Great Challenger) – Birger Jörgensen (Steen Juul)</li>



<li>Heimaey (e. S.J.&#8217;s Caviar) – Steen Juul</li>



<li>Heti (e. E L Titan) – Ken Ecce</li>



<li>Hertz (e. Readly Express) – Knud Mönster (Jeppe Juel)</li>



<li>Havanna Banker (e. Michel&#8217;s Turn) – Flemming Jensen</li>



<li>Hovita (e. Infinitif) – Kasper K Andersen (Jeppe Rask)</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">5Efter en mycket positiv insats för sulky som fyra mot elithästarna i Grand Prix Federation Regionale du Nord är idag <strong>Self Explosive </strong>(e. Explosive Matter) tillbaka för sadel i Prix Baucis (€75.000) på Vincennes (första start kl. 18.58).</p>



<p class="wp-block-paragraph">Eric Raffin rider den av Christoffer Eriksson-tränade åttaåringen över 2.700 meter voltstart i detta lopp med 33.750 euro till vinnaren.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/03/prixalencon2-617x467.jpg" alt="" class="wp-image-424479"/><figcaption class="wp-element-caption">Self Explosive tävlar åter för sadel denna fredagkväll. Foto: Gerard Forni</figcaption></figure>



<p class="wp-block-paragraph">Även Björn Goop finns representerad på Parisbanan och då genom tvååriga debutanten<strong> Lola du Campus </strong>(e. Voeland). Stoet körs av Yoann Lebourgeois i evakueringsloppet Prix Galathea (€33.000).</p>



<p class="wp-block-paragraph">Svenskintressen går även att skönja i Pornichet (första start kl. 16.17). Pierre Levesques svenskfödde sexåring<strong> Huis Clos </strong>(e. Bird Parker) jagar tredje raka sadelsegern i Prix Conseil Regional Pays de la Loire (€30.000) och så kör Marie Norberg egentränade <strong>Istania de Viette</strong> (e. Carat Williams) i Prix Rca La Radio (€26.000).</p>



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



<p class="has-drop-cap wp-block-paragraph">6Axevallatränaren David Persson har stärkt upp stallet med två nya hästar. Från Joakim Elfving kommer närmast Going Kronos-brodern <strong>Courtly Kronos</strong> (e. Trixton) 1.12,6ak/213.800 kr som ägs av Stall Heartbeat.<br>Femåringen har inte vunnit lopp sedan slutet av treåringssäsongen, men kommer närmast från en andraplats på nya rekordet 1.12,6.</p>



<p class="wp-block-paragraph">Ny hos Persson är även<strong> Walk of Life</strong> (e. Orlando Vici) 1.14,2am/229.050 kr som vunnit två av 23 starter hos Per Nordström och därtill slutat femma i ett Klass II-försök.<br>Hästen ägs av Invexbo AB &#038; Boris L Konsult AB som därmed äger tre av de 32 hästar som finns på David Perssons träningslista.</p>



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



<p class="has-drop-cap wp-block-paragraph">7På onsdag är det dags för ett nytt Breeders Crown-lopp för tvååringar och denna gång på Solvalla.</p>



<p class="wp-block-paragraph">Vinnaren av årets första BC-lopp för de yngsta heter <strong>Duncan Cowan </strong>och vann sitt lopp på Bergsåker den 25 augusti vilket var hans andra triumf i följd.<br>Nu jagar den av Svante Båth-tränade Walner-sonen ny seger i lag med Erik Adielsson.</p>



<p class="wp-block-paragraph"><strong>Startlista Breeders Crown tvååringar</strong><br><em>2.140 meter autostart, förstapris: 175.000 kronor</em></p>



<ol class="wp-block-list">
<li>Pure Eliza (e. Brillantissime) – Mats E Djuse (Kevin Gondet)</li>



<li>Hidethewinehoney (e. Orlando Vici) – Jim Oscarsson</li>



<li>Ronno (e. Walner) – Ulf Ohlsson (Reijo Liljendahl)</li>



<li>L&#8217;AmourPourBlanca (e. Face Time Bourbon) – Rick Ebbinge</li>



<li>Duncan Cowan (e. Walner) – Erik Adielsson (Svante Båth)</li>



<li>Arctic Estelle (e. Express Duo) – Jorma Kontio (Pekka Korpi)</li>



<li>Look at Me Sisu (e. Father Patrick) – Björn Goop (Gordon Dahl)</li>



<li>Captain Adore (e. Father Patrick) – Örjan Kihlström (Reijo Liljendahl)</li>



<li>Matchmadeinheaven (e. S.J.&#8217;s Caviar) – Rikard N Skoglund (Fredrik Wallin)</li>



<li>Ragazzo Zon (e. Maharajah) – Magnus A Djuse (Gordon Dahl)</li>



<li>Ebba Kuce (e. Who&#8217;s Who) – Anders Zackrisson</li>



<li>Olivia Bourbon (e. Face Time Bourbon) – Robin Bakker (Paul Hagoort)</li>
</ol>

Fokustema
Morgonsvepet
Läs senare
Auktionsstart i Eskilstuna
Om dagens auktionsstart i Eskilstuna, svensk sadelstjärna som jagar triumf på Vincennes och en Going Kronos-bror som byter regi kan du bland annat läsa i dagens morgonsvep.
