
<p class="has-drop-cap wp-block-paragraph">1Sveriges segerrikaste kusk just nu – eller landets vinstrikaste tränare? Mats E Djuse och Daniel Redén gör upp om kusktiteln när det är årsfinal i Rättvik (första start 18.20) ikväll!<br>Mats E Djuse har sedan tidigare tagit 18 kuskchampionat på svenska banor (varav ett inkasserat hittills i år), medan Daniel Redén jagar sin allra första titel. Det är fördel Djuse inför säsongsavslutningen, då han leder med 12-11 och dessutom har betydligt fler andrapris än Redén i Rättvik under säsongen. </p>



<p class="wp-block-paragraph">Mats Djuse har åtta uppsittningar, men Sveriges vinstrikaste tränare hittills 2024 har inte gett upp hoppet. Redén lastar bussen med sex egentränade hästar och kör dessutom Maria Svedberg-tränade debutanten <strong>Licorice Sisu</strong> (e. Walner) i nolloppet.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/09/admiralasokm230916adamstromstalltz-617x422.jpg" alt="" class="wp-image-496988"/><figcaption class="wp-element-caption">Daniel Redén-tränade Admiral As och Örjan Kihlström. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="wp-block-paragraph">Det stora namnet från Redén-stallet är <strong>Admiral As</strong> (e. Ready Cash), 1.10,8am*/5.474.985 kr, som vunnit 26 av 53 starter med Åby Stora Pris ifjol som största seger. Tränare Redén kör nu hästen för först gången i lopp när Admiral As ska försöka runda från 60 meters tillägg i ett långlopp. På samma startfålla finns en annan mångmiljonär i Sofia Aronsson Hofstedts <strong>Unico Broline</strong> (e. Cantab Hall) – som körs av Mats Djuse!<br>– Det kan bli ett passande lopp att testa honom och då kanske jag kan få någon ny idé vad jag kan göra med honom. Han känns fin i jobben, sedan är han ju som han är. Jag tror att han kände efter lite extra barfota runt om senast så det blir en konstig galopp. Nu går vi tillbaka till skor fram och stark är han ju, säger Daniel om Admiral As på Stall Zets hemsida.</p>



<p class="wp-block-paragraph">Skulle det knyta sig för herrar Djuse och Redén lurar Nordens segerrikaste kusk i vassen. Jorma Kontio är nämligen inte helt borta ur championstriden med tio segrar och sju styrningar ikväll.</p>



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



<p class="has-drop-cap wp-block-paragraph">2Rättvik (första start 18.20) och Eskilstuna (start 18.30) delar fredagskvällens expresstrav och förutom championstriden i Rättvik bjuds en hel del spännande fyrbenta aktörer även vid sidan av topphästarna Admiral As och Unico Broline.</p>



<p class="wp-block-paragraph">Som kallblodet <strong>Stormyrans Lasse</strong> (e. Tekno Eld) i en spårtrappa i Rättvik. Den kapable fyraåringen gick i träning till Oskar Kylin Blom i slutet av juli och för sin nye tränar har han gjort fem starter i sommar och höst – och vunnit samtliga! Med gott om pengar på bankboken för propositionen är kvällens uppgift start i tredje led bakom startbilen (spår 14).</p>



<p class="wp-block-paragraph">Thorsten Tietz gör en hel del resor från Tyskland för att köra Sybille Tinter-tränade hästar på svensk mark och i Eskilstuna sitter han upp bakom en duo. Mest meriterad är italienske <strong>Domenik Jet</strong> (e. Pine Chip), som vunnit elva av 27 starter. Hästen har växlat mellan tävlande i Sverige och Tyskland och sju av vinsterna har kommit på svensk mark. Nu ställs han bland annat mot Freddrik B Larsson-tränade Portofino (e. Charly du Noyer), som tävlat flitigt i STL-sammanhang och vunnit STL-försök både ifjol och i år.</p>



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



<p class="has-drop-cap wp-block-paragraph">3Fredagen inleds med lunchtävlingar på Umåker (första start 12.20) och avslutningen på lunchens V65-spel ser ut att bli en stallduell mellan två femåringar. Öystein Tjomsland plockar ut duon <strong>Grude Enok</strong> (e. Moe Odin) och <strong>Grisle Kongen G.L.</strong> (e. Bork Odin), som får Stefan Edin och Ulf Ohlsson i vagnen.<br>Fast spårtombolan var inte snäll mot Tjomslands hästar som inleder från innerspår på tillägg, espektive bakspår på tillägg i kampen om tävlingsdagens största prischeck på 40.000 kronor.</p>



<p class="wp-block-paragraph">En meriterad travare på nya jaktmarker är åttaårige <strong>Bravo Sabotage</strong> (e. From Above), med 17 segrar och 1,4 miljoner kronor på kontot. Hästen köptes i slutet av sommaren av Skellefteåamatören Bert Pettersson och i tredje starten i nya regin kom första segern, i norska Harstad i lördags. Nu möter han bland annat STL-härdade stoet <strong>Young Mistress</strong> (e. Orlando Vici).</p>



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



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/11/bazirebarjonprotestmarsch-617x333.jpg" alt="" class="wp-image-657138"/><figcaption class="wp-element-caption">Topptränaren Jean Michel Bazire och förbundsordföranden Jean-Pierre Barjon dök upp bland de från travsporten som demonstrerade i Paris igår.</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4Efter gårdagens manifestation mot de styrande politikerna i Frankrike med inställda tävlingar på Vincennes som följd är Parisbanan åter i elden ikväll (första start 18.15). En svensktränad häst dyker upp i startlistorna och det sker i kvällens största lopp.</p>



<p class="wp-block-paragraph">Marie Norberg startar sitt femåriga sto <strong>Justess Viking</strong> (e. Ubriaco) i Grupp II-klassade montéloppet Prix Xavier de Saint Palais (€120.000) för femåriga hingstar och ston med blott sju startande hästar. Justess Viking kommer närmast från fjärdeplatsen i ett annat Grupp II-lopp, Prix Edmond Henry (€120.000), och rids då som nu av Nathalie Henry.<br>De i särklass tyngsta meriterna i loppet har sjufaldige miljonären <strong>Jean Balthazar</strong> (e. Alto de Viette), som vunnit fyra Grupp II-lopp under sadel och slutat tvåa i tre Grupp I-löpningar.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2024-11-08/" target="_blank" rel="noreferrer noopener">Här är startlistorna till Vincennes tävlingar ikväll.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">5Den 13 juli 1994 lanserades nya spelformen V3 som ett nytt spel för banpubliken, där det handlade om att köpa andelar inför första avdelningen och dessa byttes in i totoluckan efter varje avdelning för att kunna hänga med hela vägen med andel/andelar på vinnande hästen i tredje avdelningen för att ta del av vinstpotten. </p>



<p class="wp-block-paragraph">Numera är spel via totoluckorna på banorna ett minne blott och spelbolaget ATG har inte lyckats hitta en lösning att via telefon och dator kunna använda upplägget med att välja hur man vill placera sina andelar inför varje avdelning.</p>



<p class="wp-block-paragraph">Därmed går det ursprungliga spelet i graven och framöver blir det ett rakt V3-spel med tio kronors radpris, likt spel som V4 och V5.<br>– Vi har tittat på att utveckla andelsbyte mellan avdelningarna digitalt, men kommit fram till att det är för komplext och kostsamt jämfört med den potential vi ser för närvarande, säger Peter Ågren, affärsutvecklare för hästspelen på ATG i ett pressmeddelande.<br>– I och med omställningen från terminal till digitalt spel på bana så har grundtanken med spelet, mekaniken med andelsbyte mellan avdelningarna, försvunnit, säger Ågren.</p>



<p class="wp-block-paragraph">Premiär för ”nya” V3 sker vid Rommes lunchtävlingar på måndag.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/04/romulustoomabgpr240417adamstromstalltz-617x383.jpg" alt="" class="wp-image-573345"/><figcaption class="wp-element-caption">Glada miner i vinnarcirkeln efter Romulus Toomas vinst med Mats Gabrielsson, Diedrik Meilink och Björn Goop i Vårfavoriten. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">6 Förra året slutade <strong>Romulus Tooma</strong> (e. S.J.’s Caviar) tvåa i Svensk Uppfödningslöpnong och i år kvalade han in till Svenskt Travkriterium i regi Diederik Meilink. Nu lämnar hästen Solvallatränaren och flyttas till Peter G Norman, <a href="https://www.travronden.se/travsport/handel/hastagande/tranarbyte/a/romulus-tooma-till-peter-g-norman" target="_blank" rel="noreferrer noopener">skriver Travronden</a>.<br>– Jag är nöjd med vad jag och Romulus Tooma presterat tillsammans men mitt fokus ligger på uppträning av unghästar. Nu blir Romulus snart fyra år och då får Peter G Norman ta över, säger Diederik Meilink till Travronden.</p>



<p class="wp-block-paragraph">Diederik Meilink har 35 hästar på sin träningslista. Av dem är 22 ettråingar och nio tvååringar.</p>



<p class="wp-block-paragraph">Treårige Romulus Tooma har gjort 17 starter (5-3-2) och sprungit in 1.773.000 kronor hittills i karriären. Största segrarna har kommit i Vinterfavoriten som tvååring och Vårfavoriten i april i år.</p>



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



<p class="has-drop-cap wp-block-paragraph">7Kungakronan har hamnat lite på sned för 2021-kullens store dominant den senaste tiden. <strong>Kungfufighting</strong> (e. Nuncio) vann elva av sina tolv första starter, men nu har Peter Rudbecks treåring gått segerlös från tre raka starter, däribland femteplatsen i danska Kriteriet.<br>I eftermiddag i Skive kan han bryta den trista sviten och skapa en ny, trevligare sådan när det vankas final i Danskt Avelslopp. Kungfufighting slutade fyra i sitt försök och försöksvinnarna var <strong>Kalles Krisbe Notz</strong> (e. Executive Caviar) och <strong>Kalle May</strong> (e. Great Challenger).</p>



<p class="wp-block-paragraph">På stosidan finns tvåan, trea och fyran från danska Stokriteriet med i finalfältet i Danskt Avelslopp. Keen <strong>Lady Josselyn</strong> (e. Maharajah) var tvåa trots galopp och närmast vinnaren, Adrian Kolgjini-tränade <strong>Kilimanjaro Face</strong> (e. Googoo Gaagaa), i Stokriteriet, medan <strong>Koningin</strong> (e. Great Challenger) och <strong>Karoline Gardenia</strong> (e. Great Challenger) tog platserna bakom i förra storloppsfinalen.<br>Försöken till dagens storlopp vanns av Koningin och <strong>Kaley C D </strong>(e. Wishing Stone).</p>



<h2 class="wp-block-heading">Startlista, Danskt Avelslopp hingstar/valacker</h2>



<p class="wp-block-paragraph">2.060 meter autostart, förstapris 75.000 dkr:<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li>Kanon Laser (e. One Too Many) – Steen Juul</li>



<li>Kalles Krisbe Notz (e. Executive Caviar) – Bent Svendsen</li>



<li>Kalle May (e. Great Challenger) – Patrick Larsen</li>



<li>Kingo Gardenia (e. Dominion Beach) – Martin Andreasen</li>



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



<li>Knud (e. Wishing Stone) – Markus Niklasson</li>



<li>Klinton Cloc (e. Wishing Stone) – Rene Kjaer</li>



<li>Komihak (e. Luckycharm Hanover) – Kenneth Andersen</li>



<li>Kombardo Skov (e. Dominion Beach) – Henrik Lönborg</li>



<li>Kungfufighting (e. Nuncio) – Jan Dahlgaard</li>



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



<li>Kima Kyvsgård (e. Dominion Beach) – Jeppe Rask</li>
</ol>



<h2 class="wp-block-heading">Startlista, Danskt Avelslopp ston</h2>



<p class="wp-block-paragraph">2.060 meter autostart, förstapris 75.000 dkr:<br><em>Häst (far) – Kusk</em></p>



<ol class="wp-block-list">
<li>Koningin (e. Great Challenger) – Michael Lönborg</li>



<li>Kaley C D (e. Wishing Stone) – Kasper K Andersen</li>



<li>Karoline Gardenia (e. Great Challenger) – Birger Jörgensen</li>



<li>Keen Lady Josselyn (e. Maharajah) – Steen Juul</li>



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



<li>Kirsten Tinghöj (e. Dominion Beach) – Jan Dahlgaard</li>



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



<li>Karola Shadow (e. Great Challenger) – Niclas Steinlein</li>



<li>Kleopatra (e. Dominion Beach) – Kent Friborg</li>



<li>Kirsi Laser (e. Forever Peace) – Morten Friis</li>



<li>Kit Laser (e. Forever Peace) – Anders Pedersen</li>
</ol>

Fokustema
Sju nyheter vid sju
Läs senare
Kusk eller tränare – vem kör bäst?
Redén jagar Djuse och första kuskchampionatet. Marie svenskt hopp i Grupp II-lopp på Vincennes. Spelform försvinner med stängda totoluckor. Kriteriefinalist byter tränare. Revanschsugen kulletta i storloppsfinal.
Detta och mer i fredagens nyhetssvep.
Detta och mer i fredagens nyhetssvep.
