
<p class="has-drop-cap">1Ikväll är det dags för Guldklockan på Solvalla, landets äldsta &#8221;lärlingslopp&#8221; där den förste vinnaren Torsten Jonsson korades redan 1957. Idel, ädel, travadel kan man säga om vinnarna i loppets långa historia. Här ryms namn som Karl-Gösta Fylking, Ulf Nordin, Kaj Widell, Torbjörn Jansson, Örjan Kihlström, Stefan Hultman, Stefan Melander, Daniel Redén, Mattias Djuse och Mats E Djuse för att nämnda några av de stora i historien.</p>



<p>Grundserien toppades av William Ekberg och därmed sitter han i förarsätet inför finalen. Kuskarna samlar poäng i två avdelningar, plus att grundserien räknas som ett &#8221;lopp&#8221;. Efter slutställningen i de tre avdelningarna väljer kuskarna häst i finalen, en spårtrappa som körs som kvällens sjätte lopp med hästar upp till 1.650.000 kronor på kontot och 80.000 kronor till vinnaren.</p>



<p>Förra året tog Julia Smedman hem finalen. Då fick hon välja häst som nia i finalen och valet föll på Jörgen Westholm-tränade 23-oddsaren <strong>Strong Heartbeat</strong> (e. Maharajah), som efter perfekt ryggresa spurtade hem guldklockan till Julia.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/12/strongheartbeatjsm221221adamstromstalltz-617x410.jpg" alt="" class="wp-image-394427"/><figcaption class="wp-element-caption">Julia Smedman vann finalen av Guldklockan på Solvalla med Strong Heartbeat förra året. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p><strong>Finalisterna i Guldklockan 2023:</strong><br class=""><em>Kusk, bana – Född – Anställd hos – Poäng grundserien</em></p>



<ul class="wp-block-list">
<li>William Ekberg, Solvalla – 1997 – Jörgen Westholm – 52</li>



<li>Carl Philip Lindblom, Örebro – 1996 – Åke Lindblom – 49</li>



<li>Simon Helm, Eskilstuna – 1998 – Markus B Svedberg – 38</li>



<li>Agnes Larsson, Eskilstuna – 1999 – Svante Ericsson – 35</li>



<li>Zeb Jonasson, Solvalla – 1999 – Claes Sjöström – 34</li>



<li>Niclas Hammarström, Solvalla – 1993 – Svante Båth – 30</li>



<li>Valentin Prevost, Romme – 1995 – Sybille Tinter – 30</li>



<li>Linus Lönn, Gävle – 1999 – Fredrik Wallin – 29</li>



<li>Julia Smedman, Solvalla – 2002 – Linda Smedman – 26</li>



<li>Oskar Florhed, Bergsåker – 1991 – Daniel Wäjersten – 25</li>



<li>Elias Strandberg, Romme – 1993 – Johanna K Karlsson – 24</li>



<li>Lovisa Bernmark, Eskilstuna – 2000 – Jörgen S Eriksson – 17</li>
</ul>



<p><strong>Fotnot: </strong>Martin P Djuse (25 poäng) var inkvalad, men tackade nej till finalen.</p>



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



<p class="has-drop-cap">2Årets sista V86-omgång väntar ikväll när Solvalla (första start 18.15) och Åby (start 18.27) delar på expresstravet. Nästa vecka är det V75-spel från en bana (norska Momarken) som gäller på onsdagskvällen.</p>



<p>V86-året avslutas med jackpot och drygt nio miljoner kronor extra i åttarättspotten. Björn Goop lastar tio hästar på hästbussen till Solvalla och sänder dessutom en trio till Åby. På huvudstadsbanan har stallet hästar i alla tre försöken till Solvallaseriens sista meeting för året med finaler på Solvalla den 3 januari. Bland annat plockar Goop ut <strong>Head Of State</strong> (e. Muscle Hill) i högsta klassen. Fyraåringen har vunnit hälften av livets 14 starter och inledde julmånaden med seger med skor under hovarna.</p>



<p>På Åby dyker hemmaamatören Mats Olssons valack <strong>Mr Weasley</strong> (e. S.J.’s Caviar) upp i ett treåringslopp som obesegrad med tre segrar i bagaget. Valacken ställs bland annat mot Goop-tränade serbiske valacken <strong>Stan Getz A.T.</strong> (e. Hasard Lavec), som är tillbaka på Lökene efter en utflykt till hemlandet i augusti/september. Av hästens fyra vinster har två tagits i Serbien och två på svensk mark.</p>



<p>Sista omgången i B-tränarserien för amatörtränade hästar får plats på V86-kupongen med dagens största prischeck i Sverige – 100.000 kronor – i förstapris. Gustav och Håkan B Johanssons femfaldige franske miljonär <strong>Dexter Chatho</strong> (e. Un Amour d’Haufor), som vann gulddivisionslopp på Mantorptravet i augusti och var med i Sundsvall Open Trot, jagar ensam från dubbla tillägg.</p>



<p>Sulkysports spelstuga inför V86-jackpotten med viktiga punkter, spikar, drag och favoriter i fara publiceras klockan 12.00 idag.</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/251721_V86_2023-12-20_40_1" class="">Sulkysport Lilla V86 – 15 andelar á 95 kr/styck</a></p>



<p><a href="https://www.atg.se/andelskungen/spel/206235_V86_2023-12-20_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">3På lunchbanan Bollnäs (först start 12.20) gör det bokslut för säsongen med årsfinal. Färske tusenklubbsmedlemmen Mats E Djuse väljer att köra på Solvalla idag, men kan räkna in årets andra championat, sedan han blivit avslagen ”på linjen” både på Dannero och Solänget tidigare i år.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/matsedjuse-617x333.jpg" alt="" class="wp-image-449642"/><figcaption class="wp-element-caption">Mats E Djuse. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Mats har tagit titeln på Hagmyren och har stor ledning på Umåker. Dessutom slåss han om segern både på Bergsåker (en seger bakom Daniel Wäjersten) och i Gävle (en seger bakom lillebror Magnus och på samma antal som Oskar Kylin Blom).</p>



<p>I kampen om tränartiteln har Jan-Olov Persson klart grepp, tre segrar och fler andrapris än tvåan Öystein Tjomsland, och fyra segrar fler än Tomas Pettersson.</p>



<p>Bland de fyrbenta som dyker upp finns Petterssons segermaskin <strong>Ajlexes Hans </strong>(e. Maharajah), som jagar årets nionde (!) seger. Hästen inledde med åtta segrar på de tio första starterna 2023 innan det har blivit fyra segerlösa starter i rad. Dags att bryta den sviten på hemmaplan?</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/12/231220.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">4För andra dagen i följd avgörs tävlingarna på Vincennes (första start kl. 13.55) utan svenska inslag, men ett sådant blågult bidrag går däremot att skönja vid vinterpremiären i Cagnes-sur-Mer (första start kl. 11.55).</p>



<p>Det är Ron Kuiper som startar Stall Escapades <strong>Idylle du Nord</strong> (e. Quaker Jet) i Prix Andre Et Joseph Micallef (€23.000) vilken körs av Yannick Alain Briand.</p>



<p>I Cagnes-sur-Mer travas det 27 dagar fram tills man i sedvanlig stil avrundar med Grupp I-klassade Criterium de Vitesse söndag den 10 mars vars prispengar reduceras kraftigt till år 2024 från årets nivå på 200.000 euro till 130.000 euro.</p>



<p>Därmed blir prispengarna jämställda med det pott det tävlas om i Prix de la Cote d&#8217;Azur (€130.000) torsdag den 11 januari trots att det loppet blott har Grupp III-status!</p>



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



<p class="has-drop-cap">5På tal om de södra delarna av Frankrike så är Vicent Martens hemmahörande i den regionen och han har fått en svensk segermaskin till sitt stall.</p>



<p>Det handlar om den femårige valacken<strong> General Norrgård</strong> (e. Maharajah) 1.12,9am/448.363 kr som efter att lämnat Daniel Wäjerstens stall i slutet av år 2022 räknat hem sju av 15 starter i Finland detta år.</p>



<p>Hästen ägs av Jussi Hietalahti som även är mannen bakom<strong> King Cole </strong>(e. Maharajah) som firat stora framgångar på fransk mark i just bröderna Vicent och Christophe Martens regi och nu får de även chansen att göra resultat med femåringen.</p>



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



<p class="has-drop-cap">6Annandag jul avgörs det i sedvanlig stil STL-finaler på Solvalla, men det sker med stukat deltagande i de två mest penningstinna loppen.</p>



<p>Finalen av Stoeliten – Baroness Karsks lopp – har blott samlat åtta deltagare i strid om segerchecken på 300.000 kronor och det kamperas om lika mycket i Gulddivisionens final tillika Gert Lindbergs lopp där elva hästar gör upp.</p>



<p><strong>Startlista Stoeliten, final</strong><br><em>2.140 meter autostart</em></p>



<ol class="wp-block-list">
<li>Filippa B.J. – Jorma Kontio</li>



<li>Dear Friend – Daniel Wäjersten</li>



<li>Digital Literacy – Ulf Ohlsson</li>



<li>Betting Pacer – Björn Goop</li>



<li>Kayla Westwood – Magnus A Djuse</li>



<li>Deborah S.H. – Örjan Kihlström</li>



<li>Barbro Kronos – Markus B Svedberg</li>



<li>Decision Maker – Björn Goop</li>
</ol>



<p><strong>Gulddivisionen, final</strong><br><em>2.140 meter autostart</em></p>



<ol class="wp-block-list">
<li>Chestnut Hill – Rikard N Skoglund</li>



<li>Axel Ruda – Ulf Ohlsson</li>



<li>Digital Dominance – Ken Ecce</li>



<li>Phoenix Photo – Björn Goop</li>



<li>Beartime – Carl Johan Jepson</li>



<li>Milliondollarrhyme – Erik Adielsson</li>



<li>Ultion Face – Dante Kolgjini</li>



<li>Arvid S.H. – Mika Forss</li>



<li>Rome Pays Off – Daniel Wäjersten</li>



<li>Night Brodde – Conrad Lugauer</li>



<li>Stoletheshow – Örjan Kihlström</li>
</ol>



<p><a href="https://sulkysport.se/wp-content/uploads/2023/12/26v75.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av startlistorna i sin helhet.</a></p>



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



<p class="has-drop-cap">7 Flera av de hästar som såldes på på den auktion som Srf Stable höll på Travera i slutet av november har nu hittat nya hemma. Auktionens två dyraste hästar finns numera hos Tomas Malmqvist. Det handlar dels om<strong> Landmark River </strong>(e. Propulsion) 1.11,5ak/383.500 kr som var finalist i Breeders Crown under fjolårets treåringssäsong vilket gick loss på 400.000 kronor, men även Tamla Celebers halvbror <strong>Sidney Celeber </strong>(e. Readly Express) 1.11,5ak/1.007.915 kr som kostade 300.000 kronor finns numera hos Malmqvist.</p>



<p>Den fyraårige Ultion Face-halvbrodern <strong>Bordeaux Face</strong> (e. Propulsion) 1.16,9m/21.800 kr, ropades åter för 180.000 kronor trots att hästen är segerlös elva starter in i karriären. Nu blir det Daniel Redéns uppgift att försöka råda bot på den saken. Bordeaux Face kostade tre miljoner kronor på auktion som ettåring.</p>

Fokustema
Morgonsvepet
Läs senare
Ekberg i förarsätet
Om kvällens final av Guldklockan på Solvalla, stora pengar på spel i B-tränarlopp på Åby och om en auktionsdyring som går i träning hos Daniel Redén kan du bland annat läsa i dagens morgonsvep.
