
<p class="has-drop-cap wp-block-paragraph">1En av Kalmartravets bästa hästar genom tiderna är <strong>Zenit F.</strong> (e. Historic Freight), 1.12,6ak/5.486.000 kr, som hade segern i Svenskt Travderby tillsammans med sin tränare Tommy Zackrisson som tyngsta merit. Men bland valackens 56 segrar i karriären finns även finalen i Kalmartravets Treåringsserie 1993. Andra stora namn som vunnit treåringsfinalen är Kriterievinnaren <strong>Je T’aime Express</strong> (e. Symphonic Hanover) samt mångmiljonärerna<strong> Calle Crown</strong> (e. Great Challenger), Monark Newmen (e. Orlando Vici) och <strong>Treasure Kronos </strong>(e. Raja Mirchi). </p>



<p class="wp-block-paragraph">Ikväll (första start 18.20) är det dags för årets final i treåringsserien och frågan är om någon av deltagarna nått dessa höga höjder när tävlingskarriärerna summeras. Bäst förspänt har Johan Untersteiner med en trio till start: <strong>Call Me Gleipner</strong> (e. Explosive Matter) med fyra raka segrar får sällskap från stallet av<strong> Stens Rebell</strong> (e. Up And Quick) och <strong>Eminent Kronos</strong> (e. Propulsion).</p>



<p class="wp-block-paragraph">150.000 kronor väntar vinnaren i årets final och lika mycket står på spel i fyraåringarnas finaluppgörelse. Där finns det stora hemmahoppet i amatören Elisabeth Almhedens fyraåring <strong>A Fair Day</strong> (e. Maharajah), som ståtar med två raka segrar och totalt nio vinster på livets 21 starter.</p>



<p class="wp-block-paragraph">I övrigt på unghästsidan då? Adrian Kolgjini har ett ämne i tvåårige hingsten <strong>Garland Greene</strong> (e. Greenshoe), som gjorde ett fint intryck i debuten i Kalmar för tre veckor sedan, där han vann på fina 1.15,7/1.640 meter. Nu är han tillbaka för att knipa andra raka.</p>



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



<p class="has-drop-cap wp-block-paragraph">2Romme (första start 18.30) delar kvällens expresstrav med Kalmar och på dalabanan blir det ett snabbt återseende av tävlingsbanan för Fredrik Wallin-tränade<strong> Reven Dejavu</strong> (e. Revenue). I måndags kväll vann han enkelt ett långlopp på Färjestad tillsammans med Rikard N Skoglund och ikväll väntar en ny insats över lång distans, den här gången från tillägg. Linus Lönn hoppar upp i sulkyn och duon segrade tillsammans i näst senaste starten.</p>



<p class="wp-block-paragraph">Tvååringsloppet har lockat blott fyra hästar och en av dem är Fredrik Wallins debutant <strong>Youcan&#8217;taffordme</strong> (e. Brillantissime). Hon är första startande avkomman till <strong>Toohotforyou</strong>, vars syster Inga In Heaven är mamma till förra veckans Svampen-vinnare <strong>Matchmadeinheaven</strong> (e. S.J.’s Caviar)!</p>



<p class="wp-block-paragraph">Annars blir det en rivstart på fredagen med lunchtävlingarna på Umåker (start 12.20). Snabbloppet över sprinterdistans har samlat hästar som fyrfaldige miljonären <strong>Selmer I.H. </strong>(e. Love You), startakatapulten <strong>From The Mine</strong> (e. From Above) och forne Sylvesterloppvinnaren<strong> Dwayne Zet </strong>(e. Muscle Massive) i ett litet men naggande gott sjuhästarsfält.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/10/231027.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">3Ikväll blir det comeback för internetauktioner i ASVT:s regi och planen är att hålla auktion på fredagskvällarna med start klockan 19.00. Intresset för att vara med är högt. Hela 38 hästar finns med i den digitala katalogen.</p>



<p class="wp-block-paragraph">Merparten av hästarna är fölston och här finns namn som Stochampionatsfyran <strong>Mily</strong> (e. Perhaps Love), 1.10,7ak/1.837.151 kr, och Bobtail-dottern <strong>Donna</strong> (e. Donato Hanover), som är dräktig med Fourth Dimension.</p>



<p class="wp-block-paragraph">13 starthästar bjuds också ut och här finns exempelvis<strong> Greenhill&#8217;s Rocco </strong>(e. Raja Mirchi), 1.11,8ak/407.400 kr, och fyraåriga kvartsmiljonärskan <strong>Diane P.Hill</strong> (e. Django Riff). På unghästsidan finns tre ettåringar (e. Amaru Boko, Hard Livin och Quarcio du Chene) samt två tvååringar (e. Spartan Kronos och Raja Mirchi).</p>



<p class="wp-block-paragraph">I år har ASVT arrangerat de stora ettåringsauktionerna Elitauktion och Next Generation Sale (tidigare Kriterieauktionen), samt Olle Goops Minnesauktion där levande föl-avgifter för avelshingstar såldes, samt en uppföljningsauktion till Next Generation Sale. Senaste ”vanliga” internetauktionen hölls i november förra året.</p>



<p class="wp-block-paragraph"><a href="https://auktion.asvt.se/purchase" target="_blank" rel="noreferrer noopener">Här går det att se hästarna som bjuds ut och följa budgivningen under kvällen.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4Svenskfödde <strong>Dubai Kronos </strong>(e. Ready Cash) laddar om på Vincennes (första start kl. 18.58) denna fredagkväll efter att fått nöja sig med en femteplats i debuten för Sébastien Guarato för två veckor sedan.</p>



<p class="wp-block-paragraph">Kvällens lopp är Prix Bellona (€46.000) för fyraåriga hästar som högst tjänat 99.000 euro och bland motståndarna syns Pierre Levesques svenskfödda sto <strong>Junkie</strong> (e. Varenne).</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/07/dubaikronosmf-617x333.jpg" alt="" class="wp-image-471823"/><figcaption class="wp-element-caption">Dubai Kronos gör sin andra start i ny regi. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Det avgörs därtill två Grupp III-lopp på Vincennes denna kväll, men helt utan svenskintressen. I Prix Pierre Van Troyen (€80.000) för fyra- och femåriga hästar som högst tjänat 300.000 euro lär Laurent Claude Abrivards Vittel de Brevol-son <strong>Inexess Bleu</strong> – som vann två Grupp-lopp föregående vintermeeting – få bära på favoritskapet medan de inhemska sadelhästarnas fyraåringsuppgörelse Prix Olry-Roederer (€80.000) ser ut att vara mer öppen.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2023-10-27/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna på Vincennes.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">5Idag avgörs fyra uttagningslopp till Grupp I-klassade Gran Premio Anact (€200.200) vars finaler avgörs för hingstar och ston i Turin den 18 november.</p>



<p class="wp-block-paragraph">Dagens uttagningslopp körs i Treviso och har samlat några riktigt starkt stammade deltagare. Philippe Allaire-ägda <strong>Filadonna</strong> (e. Muscle Hill) vann tävlingsdebuten på 1.17,1a/2.060 meter och har därefter bytt regi från just Allaire till Alessandro Gocciadoro.<br>Stoet som har Elitloppsvinnaren Hohnecks mormor <strong>Sanawa</strong> (e. Jeanbat du Vivier) som mor körs av Gocciadoro själv i dagens uttagningslopp.</p>



<p class="wp-block-paragraph">I hingstklassen tävlar Derbyvinnaren<strong> Expo Wise As</strong> (e. Ready Cash) halvbror <strong>Fellow Wise As</strong> (e. Maharajah). Lorenzo Baldi tränar och kör tvååringen som inlett karriären med tre segrar på de fem första starterna.</p>



<p class="wp-block-paragraph"><a href="https://ippica.snai.it/partenti/T/IT46/2023-10-27?signature=e3fb32af57cdd02ade61bccf7307ebaf70600558fc6a144aa89ceb209092dcf2" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna i Treviso.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">6Under gårdagen vann en svensk spelare 3,5 miljoner kronor på den franska spelformen Quinté vilken är namngiven High Five av deras svenska samarbetspartner Svenska Spel.</p>



<p class="wp-block-paragraph">Spelaren satte helt enkelt de fem första i mål i rätt ordningsföljd i ett galopplopp i Chantilly vilket hen var ensam om och belönades med 3.534.760 kronor.</p>



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



<p class="has-drop-cap wp-block-paragraph">7I Skive avgörs Grand Circle 4-års Championat för såväl hingstar och valacker som ston denna fredag med 220.000 danska kronor till vinnaren i respektive klass.</p>



<p class="wp-block-paragraph">Robert Bergh tar chansen med den danske derbytrean <strong>Harpy</strong> (e. Bar Hopping) som nu ska försöka vinna årets sista klassiska lopp på dansk mark och genrepet med seger i Walter Lundbergs Memorial lovade mer.</p>



<p class="wp-block-paragraph">Den äldre eliten tävlar i Geert Olesens Minneslopp och där plockar Robert Bergh även ut <strong>Pinto Bob</strong> (e. Maharajah) som får strida mot den danske VM-deltagaren <strong>Get A Wish</strong> (e. Wishing Stone).</p>



<h2 class="wp-block-heading">Startlista Grand Circle 4-års Championat h/v</h2>



<p class="wp-block-paragraph"><em>2.060 meter autostart:</em></p>



<ol class="wp-block-list">
<li>Hero Boom Bay (e. Donato Hanover) – Kasper K Andersen</li>



<li>Hollywood Stone (e. Wishing Stone) – Nicklas Korfitsen</li>



<li>Houdini Shadow (e. Lindy Lane) – Gordon Dahl</li>



<li>Hurricane K K (e. Ens Snapshot) – Rene Kjaer</li>



<li>Hnokki Speed (e. Wishing Stone) – Birger Jörgensen</li>



<li>Henrik Will (e. Great Challenger) – Ken Ecce</li>



<li>Harboe (e. Goetmals Wood) – Jeppe Rask</li>



<li>Howlingatthemoon (e. Cantab Hall) – Jan Dahlgaard</li>



<li>Harpy (e. Bar Hopping) – Robert Bergh</li>



<li>Heavenly Stone (e. Wishing Stone) – Knud Mönster</li>



<li>High Five (e. Quite Easy) – Flemming Jensen</li>



<li>Hugo Tröjberg (e. Hillustrious) – Bo Westergaard</li>
</ol>



<h2 class="wp-block-heading">Startlista Grand Circle 4-års Championat ston</h2>



<p class="wp-block-paragraph"><em>2.060 meter autostart:</em></p>



<ol class="wp-block-list">
<li>Havanna Sotto (e. Bird Parker) – Ken Ecce</li>



<li>Hope Never Dies (e. S.J.’s Caviar) – Ulrik Christoffersen</li>



<li>Heimaey (e. S.J.’s Caviar) – Steen Juul</li>



<li>Hollywood (e. Great Challenger) – Jeppe Juel</li>



<li>Hallöjsa Vang (e. S.J.’s Caviar) – Bo Westergaard</li>



<li>Herina Sotto (e. Love You) – Nicklas Korfitsen</li>



<li>Helena D D (e. Orlando Vici) – Kasper K Andersen</li>



<li>Hazy Brogård (e. Wishing Stone) – Rene Kjaer</li>



<li>Hovita (e. Infinitif) – Jeppe Rask</li>



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



<li>Herecomes Gardenia (e. Great Challenger) – Adrian Solberg Akselsen</li>



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

Fokustema
Morgonsvepet
Läs senare
Hemmaseger i finalen?
Om kvällens årgångsfinaler i Kalmar, ASVT:s återstart av auktion och penningstinna danska fyraåringsuppgörelser går bland annat att läsa i veckans femte morgonsvep.
