<p>I ett tidsdokument berättar Sulkysport vad som hänt på vägen från att Propulsion nervsnittades den 27 april 2015 i USA via Stall Zets köp i USA 2 augusti samma år till att norska facktidningen Trav-og Galopp-Nytt avslöjade nervsnittningen efter Propulsions seger i Elitloppet 2020 fram till förhandlingen i överdomstolen som startar i morgon i Hästsportens Hus:</p>
<h2>27 april 2015:</h2>
<p>Propulsion nervsnittas på höger och vänster framben av veterinär Patricia M. Hogan på Hogan Equine-kliniken på Fair Winds Farm i staten New Jersey i USA.</p>
<p><a href="https://sulkysport.se/wp-content/uploads/2020/10/skarmavbild20201028kl.11.40.04.png"><img class="aligncenter wp-image-118866 size-full" src="https://sulkysport.se/wp-content/uploads/2020/10/skarmavbild20201028kl.11.40.04.png" alt="" width="566" height="310" /></a></p>
<h2><strong>2 augusti 2015:</strong></h2>
<p>Fyraårige Propulsion bjuds ut till försäljning på Tattersalls mixedauktion på Meadowlands. Inga uppgifter gör gällande i auktionskatalogen att hästen har nervsnittats. Hästen ropas in för 210.000 dollar för Stall Zets (Brixton Medical AB) räkning.</p>
<figure id="attachment_118868" aria-describedby="caption-attachment-118868" style="width: 617px" class="wp-caption aligncenter"><a href="https://sulkysport.se/wp-content/uploads/2020/10/propulsionsimhagen-scaled.jpg"><img class="wp-image-118868 size-sulky-mellan2" src="https://sulkysport.se/wp-content/uploads/2020/10/propulsionsimhagen-617x412.jpg" alt="" width="617" height="412" /></a><figcaption id="caption-attachment-118868" class="wp-caption-text">Propulsion säljs på Meadowlands. Foto: Simon Hagen/stalltz.se</figcaption></figure>
<h2><strong>18 augusti 2015:</strong></h2>
<p>En handläggare på det amerikanska travförbundet U.S.T.A. skriver till Propulsions ägare Brittany Farms att det kommit till U.S.T.A:s kännedom att Propulsion blivit nervsnittad och begär in uppgifter om detta, vilket också sker. Två dagar tidigare (16 augusti) anländer Propulsion till Daniel Redéns stall i Örsundsbro.</p>
<p><a href="https://sulkysport.se/wp-content/uploads/2020/10/skarmavbild20201028kl.11.46.20.png"><img class="aligncenter wp-image-118873 size-full" src="https://sulkysport.se/wp-content/uploads/2020/10/skarmavbild20201028kl.11.46.20.png" alt="" width="581" height="389" /></a></p>
<h2><strong>14 september 2015:</strong></h2>
<p>Det amerikanska travförbundet U.S.T.A. skriver i det exportcertikat som är daterat den 14 september 2015 och som sänds till Svensk Travsport att hästen är nervsnittad (low nerved left front, low nerved right front). Uppgifterna om att Propulsion är nervsnittad finns i flera olika dokument som tillsänts ST.</p>
<p><a href="https://sulkysport.se/wp-content/uploads/2020/10/skarmavbild20201028kl.11.39.42.png"><img class="aligncenter wp-image-118875 size-sulky-liten2" src="https://sulkysport.se/wp-content/uploads/2020/10/skarmavbild20201028kl.11.39.42-350x258.png" alt="" width="350" height="258" /></a></p>
<h2><strong>11 september 2015:</strong></h2>
<p>Svensk Travsport skickar ut ett brev till Brixton Medical AB att hästen är införd i Svensk Travsports importregister utan notering om att Propulsion är nervsnittad, vilket däremot uppges i exportcertifikatet från U.S.T.A.</p>
<p><a href="https://sulkysport.se/wp-content/uploads/2020/10/skarmavbild20201028kl.11.50.39.jpg"><img class="aligncenter wp-image-118876 size-sulky-mellan2" src="https://sulkysport.se/wp-content/uploads/2020/10/skarmavbild20201028kl.11.50.39-617x435.jpg" alt="" width="617" height="435" /></a></p>
<h2><strong>14 september 2015:</strong></h2>
<p>Stall Zet (Daniel Redén) registreras som ägare till Propulsion på travsport.se.</p>
<h2><strong>23 september 2015:</strong></h2>
<p>Propulsion tas in på Daniel Redéns träningslista.</p>
<h2><strong>7 oktober 2015:</strong></h2>
<p>Propulsion debuterar på Solvalla och vinner med Daniel Redén i sulkyn.</p>
<h2><strong>8 maj 2016:</strong></h2>
<p>Propulsion ska starta i Finlandia-Ajo i Vermo och ST utfärdar exportcertifikat där uppgifter saknas att Propulsion är nervsnittad.</p>
<p><a href="https://sulkysport.se/wp-content/uploads/2020/10/skarmavbild20201028kl.11.54.16.jpg"><img class="aligncenter wp-image-118877 size-sulky-mellan2" src="https://sulkysport.se/wp-content/uploads/2020/10/skarmavbild20201028kl.11.54.16-617x826.jpg" alt="" width="617" height="826" /></a></p>
<h2><strong>3 november 2016:</strong></h2>
<p>Propulsion genomför avelsvärdering utan att någon av avelsvärderingsnämndens fem ledamöter (ordförande Håkan Persson, Stefan Johansson, Ulrika Lundberg samt veterinärerna Lars Johansson och Matts Olof Nord) noterar att hästen är nervsnittad trots att detta finns noterat i det amerikanska travförbundets dokument.</p>
<p><a href="https://sulkysport.se/wp-content/uploads/2020/10/skarmavbild20201028kl.11.55.48.png"><img class="aligncenter wp-image-118879 size-sulky-mellan2" src="https://sulkysport.se/wp-content/uploads/2020/10/skarmavbild20201028kl.11.55.48-617x366.png" alt="" width="617" height="366" /></a></p>
<h2><strong>20 november 2016:</strong></h2>
<p>Propulsion ska starta på Vincennes i Frankrike. ST utfärdar exportcertifikat där uppgifter saknas att Propulsion är nervsnittad.</p>
<h2><strong>7 maj 2017:</strong></h2>
<p>Propulsion ska starta i Finlandia-Ajo i Vermo och ST utfärdar exportcertifikat där uppgifter saknas att Propulsion är nervsnittad.</p>
<h2><strong>12 oktober 2017:</strong></h2>
<p>Propulsion ska starta på Vincennes i Frankrike. ST utfärdar exportcertifikat där uppgifter saknas att Propulsion är nervsnittad.</p>
<h2><strong>27 januari 2019:</strong></h2>
<p>Propulsion ska starta på Vincennes i Frankrike. ST utfärdar exportcertifikat där uppgifter saknas att Propulsion är nervsnittad.</p>
<h2><strong>19 september 2019:</strong></h2>
<p>Propulsion ska starta på Vincennes i Frankrike. ST utfärdar exportcertifikat där uppgifter saknas att Propulsion är nervsnittad.</p>
<h2><strong>21 januari 2020:</strong></h2>
<p>Propulsion ska starta på Vincennes i Frankrike. ST utfärdar exportcertifikat där uppgifter saknas att Propulsion är nervsnittad.</p>
<h2><strong>31 maj 2020:</strong></h2>
<p>Propulsion och Örjan Kihlström vinner Elitloppet på Solvalla.</p>
<figure id="attachment_93212" aria-describedby="caption-attachment-93212" style="width: 617px" class="wp-caption aligncenter"><a href="https://sulkysport.se/wp-content/uploads/2020/05/propulsionmal2.jpg"><img class="size-sulky-mellan2 wp-image-93212" src="https://sulkysport.se/wp-content/uploads/2020/05/propulsionmal2-617x333.jpg" alt="" width="617" height="333" /></a><figcaption id="caption-attachment-93212" class="wp-caption-text">Propulsion och Örjan Kihlström spurtar hem Elitloppet. Foto: Mathias Hedlund</figcaption></figure>
<h2><strong>2 juni 2020:</strong></h2>
<p>Norska Trav-og Galopp-Nytt avslöjar att Propulsion nervsnittades i USA.</p>
<p><a href="https://sulkysport.se/wp-content/uploads/2020/10/skarmavbild20201028kl.12.01.56.jpg"><img class="aligncenter size-full wp-image-118881" src="https://sulkysport.se/wp-content/uploads/2020/10/skarmavbild20201028kl.12.01.56.jpg" alt="" width="584" height="414" /></a></p>
<h2>3 juni 2020:</h2>
<p>Sulkysport plockar fram<a href="https://sulkysport.se/beviset-for-nervsnittningen/" target="_blank" rel="noopener noreferrer"> dokumentet</a> som visar att Propulsion nervsnittats med hjälp av diod-laser på Propulsions båda framhovar på Hogan Equine på Fair Winds Farm den 27 april 2015, vilket framgår av det dokument (se längre upp i texten) som är undertecknat av veterinär Patrica M. Hogan, VMD, Diplomate, American College of Veterinary Surgeous.</p>
<p><a href="https://sulkysport.se/wp-content/uploads/2020/10/skarmavbild20201028kl.12.05.26.jpg"><img class="aligncenter size-sulky-mellan2 wp-image-118882" src="https://sulkysport.se/wp-content/uploads/2020/10/skarmavbild20201028kl.12.05.26-617x481.jpg" alt="" width="617" height="481" /></a></p>
<h2>3 juni 2020:</h2>
<p>Svensk Travsports verkställande direktör Maria Croon berättar att Propulsion tilldelats startförbud. I samma veva skriver Svensk Travsport på sin hemsida:</p>
<p><em>”Svensk Travsport får också många frågor avseende Propulsions avelsverksamhet och därvidlag har Propulsion fortfarande ett gällande betäckningsbevis, utifrån tidigare genomförd avelsvärdering. En ny avelsvärdering kan, enligt kapitel 25 kap. paragraf 6 Registreringsreglementet, bli aktuell när utredningen är klar. Detta innebär att redan födda avkommor samt de betäckningar som görs i år inte kommer att påverkas, oavsett slutligt beslut i ärendet. Svensk Travsport kommer också inleda en intern utredning för att genomlysa förbundets process och hantering.”</em></p>
<h2>3 juni 2020:</h2>
<p>Travförbundets vd Maria Croon intervjuas i en TV4-sändning och lägger <a href="https://sulkysport.se/kronika/vari-ligger-sts-ansvar/" target="_blank" rel="noopener noreferrer">skuldbördan</a> i Propulsion-affären på tränaren Daniel Redén.</p>
<figure id="attachment_90911" aria-describedby="caption-attachment-90911" style="width: 617px" class="wp-caption aligncenter"><a href="https://sulkysport.se/wp-content/uploads/2020/05/img9362-scaled.jpg"><img class="size-sulky-mellan2 wp-image-90911" src="https://sulkysport.se/wp-content/uploads/2020/05/img9362-617x463.jpg" alt="" width="617" height="463" /></a><figcaption id="caption-attachment-90911" class="wp-caption-text">Svensk Travsports versktällande direktör Maria Croon. Foto: Claes Freidenvall</figcaption></figure>
<h2>8 juni 2020:</h2>
<p>Svensk Travsport tar in externa utredare för att ”stärka” utredningen runt Propulsion, juristen Pehr Jern och tidigare kriminalpolisen <a href="https://sulkysport.se/kronika/dataintrang-av-st/" target="_blank" rel="noopener noreferrer">Roger Lindblom</a> från Secorum AB.</p>
<h2>7 juli 2020:</h2>
<p>Svensk Travsport sparkar utrednings- och säkerhetschefen <a href="https://sulkysport.se/propulsion-utredaren-fick-sparken/" target="_blank" rel="noopener noreferrer">Steen Morten Eidsmo Johansen</a> med anledning av Propulsion-affären. Anledningen är ”meningsskiljaktigheter” och en direkt utlösande faktor till att hans anställning avslutas var olika uppfattningar mellan Johansen och ST:s verkställande direktör Maria Croon om hur den pågående utredningen av Propulsions nervsnittning ska skötas.</p>
<h2>29 oktober: 2020</h2>
<p>Sulkysport listar de <a href="https://sulkysport.se/far-stall-zet-sta-for-kalaset/" target="_blank" rel="noopener">153 hästar</a> som kan se fram emot prispengar om ST anser att Stall Zet ska betala samtliga pengar till de hästar som varit placerade bakom Propulsion.</p>
<figure id="attachment_119066" aria-describedby="caption-attachment-119066" style="width: 617px" class="wp-caption aligncenter"><a href="https://sulkysport.se/wp-content/uploads/2020/10/img3216.jpeg"><img class="size-sulky-mellan2 wp-image-119066" src="https://sulkysport.se/wp-content/uploads/2020/10/img3216-617x328.jpeg" alt="" width="617" height="328" /></a><figcaption id="caption-attachment-119066" class="wp-caption-text">Utredaren Pehr Jern, vice vd Ulf Hörnberg, förbundsjuristen Göran Wahlman, ST:s ordförande Marjaana Alaviuhkola och vd Maria Croon vid presskonferensen om Propulsion. Foto: stalltz.se</figcaption></figure>
<p>Svensk Travsport presenterar sin <a href="https://sulkysport.se/propulsions-svenska-starter-ogiltigforklaras/" target="_blank" rel="noopener">utredning</a> gällande Propulsion och där förbundet kommit fram till slutsatsen att det är bevisat att hästen tävlat nervsnittad. Alla hästens 45 starter i Sverige ogiltigförklaras och prispengarna ska återkrävas från ägaren Stall Zet.</p>
<p>Daniel Redéns advokat <a href="https://sulkysport.se/en-extremt-marklig-slutsats/" target="_blank" rel="noopener">Jesper Arvenberg</a> blev inte inbjuden till ST:s presskonferens om Propulsion-affären utan fick lyssna via länk.</p>
<p>– Jag tycker att beslutet är oövervägt och i vart fall som den interna utredningen presenterades så känns den inte så grundlig som man hade önskat eftersom ansvaret i alla delar tycks vara outrett. Man kommer till slutsatsen att något gått fel och ingen är ansvarig och det är lite svårt att förstå, säger Jesper Arvenberg.</p>
<h2>3 november 2020:</h2>
<p>Stall Zet och Daniel Redéns advokat kan inte svara på frågor från <a href="https://sulkysport.se/st-haller-inne-utredning/" target="_blank" rel="noopener">Sulkysport</a> om utredningen kring Propulsion och inte heller det beslut om att ogiltigförklara avelsvärderingen eftersom ST har inte gett Jesper Arvenberg tillgång till varken beslut eller utredning.</p>
<h2>5 november 2020:</h2>
<p>Skandalen växer runt ST och Propulsion-gate blir bara smutsigare och smutsigare, skriver Sulkysports chefredaktör Claes Freidenvall i en <a href="https://sulkysport.se/kronika/nya-dimridaer-i-propulsion-gate/" target="_blank" rel="noopener">krönika</a>.</p>
<h2>7 november 2020:</h2>
<figure id="attachment_55083" aria-describedby="caption-attachment-55083" style="width: 617px" class="wp-caption aligncenter"><a href="https://sulkysport.se/wp-content/uploads/2019/11/deovolente110801staty.jpg"><img class="size-sulky-mellan2 wp-image-55083" src="https://sulkysport.se/wp-content/uploads/2019/11/deovolente110801staty-617x410.jpg" alt="" width="617" height="410" /></a><figcaption id="caption-attachment-55083" class="wp-caption-text">Deo Volente Farms blir Propulsions nya hem. Foto: stalltz.se</figcaption></figure>
<p>Propulsion har fått ett nytt hem och flyttar till<a href="https://sulkysport.se/propulsions-nya-hem/" target="_blank" rel="noopener"> USA</a>.</p>
<h2>17 november 2020:</h2>
<p>Steen Morten E. Johansen, tidigare säkerhetschef på ST, skriver ett <a href="https://sulkysport.se/oppet-brev-till-maria-croon/" target="_blank" rel="noopener">”öppet brev”</a> till ST:s vd Maria Croon efter att han utsatts för flera mycket starka personangrepp utan han fått möjligheten att försvara sig i samband med den presskonferens ST höll.</p>
<p>Travförbundets tidigare säkerhetschef Steen Morten E. Johansen begär i ett ”öppet brev” till ST:s verkställande direktör Maria Croon att få den del av det sekretessavtal han ingått med travförbundet som rör just Propulsion upplöst. <a href="https://sulkysport.se/kronika/en-rimlig-begaran/" target="_blank" rel="noopener">”En rimlig begäran”</a>, anser Sulkysports chefredaktör Claes Freidenvall.</p>
<p>ST:s vd Maria Croon <a href="https://sulkysport.se/sts-vd-svarar-pa-oppet-brev/" target="_blank" rel="noopener">svarar</a> på ”öppet brev” från ST:s tidigare säkerhetschef Steen Morten Eidsmo Johansen.</p>
<h2>27 januari 2021:</h2>
<p>Propulsion har fått klartecken att användas i avel i fem nya länder.</p>
<p>– Belgien, Danmark, Holland, Italien och Norge har sagt ja. Nu väntar vi också på svar från Finland och Tyskland som ska ta upp frågan den 1 februari, säger <a href="https://sulkysport.se/fritt-fram-for-propulsion-i-fem-nya-lander/" target="_blank" rel="noopener">Johan Arneng</a>, avelsansvarig hos Stall Zet.</p>
<h2>2 februari 2021:</h2>
<p><a href="https://sulkysport.se/finland-ger-gront-ljus/" target="_blank" rel="noopener">Finland</a> ger grönt ljus för Propulsion som avelshingst.</p>
<h2>4 februari 2021:</h2>
<p>Tyska travförbundet <a href="https://sulkysport.se/propulsion-godkand-i-tyskland/" target="_blank" rel="noopener">HVT</a> lämnade besked om att att Propulsion får nyttjas som listhingst i Tyskland.</p>
<h2>12 februari 2021:</h2>
<p>Propulsion anmäls till <a href="https://sulkysport.se/blir-propulsion-godkand-for-svensk-avel/" target="_blank" rel="noopener">avelsvärderingen</a> på Solvalla.</p>
<h2>14 februari 2021:</h2>
<p>ST:s jurist <a href="https://sulkysport.se/detta-galler-for-propulsion-avkommor/" target="_blank" rel="noopener">Göran Wahlman</a> reder ut vad som gäller för Propulsions avkommor som föds 2022:</p>
<p>– Om ett svenskregistrerat sto betäcks utomlands så måste betäckningen ske utanför Europa för att avkomman ska kunna registreras med fulla rättigheter. I annat fall, vid betäckning inom Europa, måste stoet vara definitivt exporterat och tillhöra annan stambok vid betäckningstillfället.</p>
<h2>17 februari 2021:</h2>
<p><a href="https://sulkysport.se/kronika/vem-tar-notan/" target="_blank" rel="noopener">”Vem står för notan”</a>, undrar Sulkysports chefredaktör Claes Freidenvall i en krönika om Svensk Travsport skulle förlora processen mot Propulsion &#038; Co.</p>
<h2>1 mars 2021:</h2>
<p>UET:s avelskommitté <a href="https://sulkysport.se/kronika/gar-st-emot-uets-avelskommitte/" target="_blank" rel="noopener">beslutade</a> vid ett möte att alla europeiska länder har rätt att registrera inseminationer med sperma – läs Propulsion – som importeras oavsett land.</p>
<p>Som ett resultat av detta möte beslutade det tyska travförbundet HVT att uppfylla UET:s avelskommittés krav och registrera alla inseminationer gällande Propulsion oavsett ursprungsland för den sperma som används.</p>
<h2>2 mars 2021:</h2>
<figure id="attachment_137526" aria-describedby="caption-attachment-137526" style="width: 617px" class="wp-caption aligncenter"><a href="https://sulkysport.se/wp-content/uploads/2021/02/hornbergulfportr.jpg"><img class="size-sulky-mellan2 wp-image-137526" src="https://sulkysport.se/wp-content/uploads/2021/02/hornbergulfportr-617x333.jpg" alt="" width="617" height="333" /></a><figcaption id="caption-attachment-137526" class="wp-caption-text">Ulf Hörnberg. Foto Mia Törnberg/Sulkysport</figcaption></figure>
<p>Svensk Travsport behöver inte ta rygg på Tyskland och följa <a href="https://sulkysport.se/inget-beslutande-organ/" target="_blank" rel="noopener">UET:s avelskommittés beslut</a> om att registrera alla inseminationer gällande Propulsion oavsett ursprungsland för den sperma som används.</p>
<p>– UET:s avelskommittè är inget beslutande organ. Kommittén kan rekommendera och föreslå beslut till UET:s styrelse, säger travförbundets vice vd Ulf Hörnberg i ett uttalande.</p>
<h2>23 mars 2021:</h2>
<p>Amerikanska travförbundet USTA ändrar sitt regelverk efter<a href="https://sulkysport.se/nya-regler-for-nervsnittning/" target="_blank" rel="noopener"> Propulsion-affären</a>. Från den 1 maj 2021 ska ”nervsnittning” rapporteras in till USTA senast 30 dagar efter ingreppet.</p>
<h2>30 mars 2021:</h2>
<p><a href="https://sulkysport.se/tummen-ner-for-propulsion/" target="_blank" rel="noopener">Avelsvärderingsnämnden</a> vänder tummen ner för Propulsion som listhingst i Sverige 2021.</p>
<h2>1 april 2021:</h2>
<p>Efter att avelsvärderingsnämnden sagt nej till Propulsion som listhingst i Sverige finns det möjlighet att nyttja hans tjänster på annat håll.</p>
<p>I tolv andra länder – Australien, Belgien, Danmark, Finland, Holland, Irland, Italien, Kanada, Nya Zeeland, Norge, Tyskland och USA – <a href="https://sulkysport.se/detta-galler-for-propulsion/" target="_blank" rel="noopener">får Propulsion användas i aveln</a>.</p>
<h2>6 april 2021:</h2>
<p>Veterinär <a href="https://sulkysport.se/kronika/regler-ar-till-for-att-foljas-eller/" target="_blank" rel="noopener">Gunnar Rangul,</a> reserverade sig mot avelsvärderingens beslut att icke godkänna Propulsion som listhingst och i sin reservation skrev han bland annat:</p>
<p>”Jag anser att synnerliga skäl föreligger för att godkänna Propulsion enligt Svensk Travsports avels- och registreringsreglemente kapitel 20, paragraf 6. Det finns idag ingen vetenskaplig dokumentation på att orsaken till ingreppet nedärvs och att hans avelslinjers avkommor i högre grad utsätts för genetiska risker, jämfört med övriga avelslinjer hos den varmblodiga travhästen. I Svensk Travsports avels- och registreringsreglemente, kapitel 1, paragaf 5, 7 och nio samt kapitel 10, paragraf 7, stycke 2, erkänner Svensk Travsport regelverket kring stamboksföring i övriga UET-länder samt Nordamerika. Att utesluta Propulsion som listhingst i svensk avels stöds inte av andemeningen i dessa paragrafer.”</p>
<h2>8 april 2021:</h2>
<p>Ansvars- och disciplinnämndens ordförande <a href="https://sulkysport.se/problemet-har-varit-st/" target="_blank" rel="noopener">Sari Olausson</a> avslöjar för Sulkysport, att det är ST som förhalar Propulsion-utredningen och ingen annan.</p>
<p>– Travförbundet vägrar att lämna ut allt förundersökningsmaterial och har dessutom gallrat och uppgiftsminimerat materialet. ST kan inte ensidigt bestämma vad dom inte anser har betydelse för utredningen. Detta är huvudorsaken till att det dröjt.</p>
<h2>15 april 2021:</h2>
<figure id="attachment_150693" aria-describedby="caption-attachment-150693" style="width: 617px" class="wp-caption aligncenter"><a href="https://sulkysport.se/wp-content/uploads/2021/04/avhopp.jpg"><img class="size-sulky-mellan2 wp-image-150693" src="https://sulkysport.se/wp-content/uploads/2021/04/avhopp-617x333.jpg" alt="" width="617" height="333" /></a><figcaption id="caption-attachment-150693" class="wp-caption-text">Juristerna Sari Olausson och Anette Fassl ställde sina platser till förfogande i STAD i ett öppet brev till Svensk Travsports styelse. Foto Mia Törnberg/Sulkysport</figcaption></figure>
<p>Sari Olausson, ordförande i STAD och Anette Fassl, vice ordförande i STAD har denna dag beslutat att ställa våra platser till förfogande. I ett <a href="https://sulkysport.se/debatt/oppet-brev-till-sts-styrelse-2/" target="_blank" rel="noopener">”öppet brev”</a> till ST:s styrelse förklarar de två juristerna i Svensk Travsports Ansvars- och Discplinnämnd orsaken.</p>
<h2>16 april 2021:</h2>
<p>Sulkysports chefredaktör Claes Freidenvall kommenterar under rubriken <a href="https://sulkysport.se/kronika/en-sorgens-dag/" target="_blank" rel="noopener">”En sorgens dag”</a> den bild som ansvar- och disciplinnämndens ordförande Sari Olausson och vice ordförande Anette Fassl målade upp i ett ”öppet brev till ST:s styrelse” och att det är ett skrik på hjälp från travsportens mest kompetenta jurister till att återbörda rättssäkerhet för de aktiva.</p>
<p><a href="https://sulkysport.se/svar-pa-oppet-brev-fran-stad/" target="_blank" rel="noopener">Svensk Travsports styrelse svarar</a> på det ”öppna brevet” från Sari Olausson, ordförande i STAD och Anette Fassl, vice ordförande i STAD.</p>
<p>I en <a href="https://sulkysport.se/kronika/smiter-undan-ansvar/" target="_blank" rel="noopener">krönika</a> skriver Sulkysports chefredaktör Claes Freidenvall att ST:s styrelse smiter undan ansvar när den undviker att svara på det självklara i det ”öppna brevet”:</p>
<p>”Att ST under en pågående process och dessutom efter den förberedande förhandlingen med Daniel Redéns ombud Jesper Arvenberg, ansvar- och disciplinsnämndens ordförande och vice ordförande gallrat i materialet är inte okey på något sätt utan ett grovt övertramp. Det ansvaret kan varken ST:s ledning eller styrelse smita ifrån hur gärna de än vill”, skriver Freidenvall.</p>
<figure id="attachment_119658" aria-describedby="caption-attachment-119658" style="width: 350px" class="wp-caption alignright"><a href="https://sulkysport.se/wp-content/uploads/2020/11/jesperarvenberg.jpg"><img class="size-sulky-liten2 wp-image-119658" src="https://sulkysport.se/wp-content/uploads/2020/11/jesperarvenberg-350x420.jpg" alt="" width="350" height="420" /></a><figcaption id="caption-attachment-119658" class="wp-caption-text">Jesper Arvenberg.</figcaption></figure>
<p>ST har <a href="https://sulkysport.se/materialet-som-st-tog-bort/" target="_blank" rel="noopener">valt att radera bort</a> viktiga och uppgifter ur Propulsion-utredningen och tagit bort sådant som kan vara till last för ST:s eget ansvar. Det visar Daniel Redéns advokat Jesper Arvenberg i ett utdrag från Redéns Pathway-konto hos det amerikanska travförbundet USTA.</p>
<h2>19 april 2021:</h2>
<p>Sulkysport visar genom STAD:s material att Svensk Travsport för egen maskin varit djupt involverad och aktiva i utredningarna runt Propulsion och Daniel Redén och detta på allra högsta chefsnivå.</p>
<p>Travförbundets vd Maria Croon, vice vd Ulf Hörnberg och förbundsjuristen Göran Wahlman har varit aktiva på flera olika sätt och bland annat hållit egna förhör, skriver Sulkysports chefredaktör Claes Freidenvall i en krönika under rubriken <a href="https://sulkysport.se/kronika/all-objektivitet-som-bortblast/" target="_blank" rel="noopener">”All objektivitet bortblåst.”</a></p>
<h2>29 april 2021:</h2>
<p>Svensk Travsports Ansvars- och Disciplinnämnd (STAD) får <a href="https://sulkysport.se/nya-ledamoter-propulsion-forhandlingar-skjuts-upp/" target="_blank" rel="noopener">nya ersättare</a> efter att Sari Olausson och Anette Fassl ställt sina platser till förfogande. Björn Samuelsson tidigare juristsuppleant i drygt tio år och Monique Wadsted blir nya ledamöter i Svensk Travsports ansvars- och disciplinnämnd (STAD).</p>
<h2>13 maj 2021:</h2>
<p>Under rubriken <a href="https://sulkysport.se/kronika/gar-det-gora-bocken-till-tradgardsmastare/" target="_blank" rel="noopener">”Går det att göra bocken till trädgårdsmästare?”</a>, skriver Sulkysports chefredaktör Claes Freidenvall i en krönika, att det skaver att Svensk Travsports styrelse utser två ledamöter i STAD (Svensk Travsports ansvars- och disciplinnämnd) utan domarbakgrund.</p>
<h2>16 maj 2021:</h2>
<figure id="attachment_118371" aria-describedby="caption-attachment-118371" style="width: 350px" class="wp-caption alignright"><a href="https://sulkysport.se/wp-content/uploads/2020/10/agerupbengtportr.jpg"><img class="size-sulky-liten2 wp-image-118371" src="https://sulkysport.se/wp-content/uploads/2020/10/agerupbengtportr-350x189.jpg" alt="" width="350" height="189" /></a><figcaption id="caption-attachment-118371" class="wp-caption-text">Stall Zets grundare Bengt Ågerup. Foto Mia Törnberg/Sulkysport</figcaption></figure>
<p>Stall Zets grundare Bengt Ågerup går till hårt angrepp mot Svensk Travsports vd Maria Croon i ett facebook-inlägg och skriver att <a href="https://sulkysport.se/maria-croon-svamlar-igen/" target="_blank" rel="noopener">”hon svamlar”</a> gällande utredningen runt Propulsion.</p>
<h2>13 juni 2021:</h2>
<p>Finska travförbundets styrelse i Suomen Hippos beslutar att annullera Propulsions två starter i Finland 2016 och 2017 och att prispengarna kommer att <a href="https://sulkysport.se/propulsion-diskad-i-finland/" target="_blank" rel="noopener">återvinnas av Svensk Travsport</a>.</p>
<p>– Felet som möjliggjort tävlandet i Finland har skett i centralorganisationen, och vi har mycket begränsade möjligheter att få pengar tillbaka av privata personer, säger Suomen Hippos ordförande Kari Eriksson.</p>
<h2>19 augusti 2021:</h2>
<p><a href="https://sulkysport.se/kronika/ge-allmanheten-tilltrade/" target="_blank" rel="noopener">Ge allmänheten tillträde till Propulsion-målet</a>, skriver Sulkysports chefredaktör Claes Freidenvall i en krönika. Han konstaterar att det är ”oerhört olyckligt när det handlar om Sveriges största travmål genom tiderna inom ramen för ansvarsnämnd och överdomstol. ”</p>
<p>Daniel Redéns advokat Jesper Arvenberg levererar en riktig kioskvältare då han avslöjar att <a href="https://sulkysport.se/fullt-logisk-reaktion-att-lita-pa-st/" target="_blank" rel="noopener">”Propulsion har full nervutväxt i hovarna”</a> efter en oerhört avancerad undersökning av som visat att hästen inte är nervsnittad utan att han har full nervutväxt i hovarna.</p>
<h2>24 augusti 2021:</h2>
<p>Sulkysports chefredaktör Claes Freidenvall skriver i en krönika under rubriken <a href="https://sulkysport.se/kronika/rott-kort-till-travforbundet/" target="_blank" rel="noopener">”Rött kort till travförbundet”</a> att rättegången mot Daniel Redén inte borde blivit av om ST haft ett modernt ledarskap och skött sina förehavanden på ett korrekt sätt.</p>
<h2>24 september 2021:</h2>
<figure id="attachment_2344" aria-describedby="caption-attachment-2344" style="width: 617px" class="wp-caption aligncenter"><a href="https://sulkysport.se/wp-content/uploads/2017/02/redendanielmia-1.jpg"><img class="size-sulky-mellan2 wp-image-2344" src="https://sulkysport.se/wp-content/uploads/2017/02/redendanielmia-1-617x334.jpg" alt="Daniel Redén, liksom Örjan Kihlström var besvikna efter loppet. Foto Mia Törnberg" width="617" height="334" /></a><figcaption id="caption-attachment-2344" class="wp-caption-text">Daniel Redén. Foto Mia Törnberg</figcaption></figure>
<p><a href="https://sulkysport.se/ingen-pafoljd-for-reden/" target="_blank" rel="noopener">Daniel Redéns döms</a> i Svensk Travsports Ansvarsnämnd (STAD) till ansvar enligt paragraf 72 i Tävlingsreglementet, men befrias från påföljd i Propulsion-affären.</p>
<p><a href="https://sulkysport.se/en-form-av-delad-seger/" target="_blank" rel="noopener">En form av delad seger</a>. Så sammanfattar Daniel Redéns advokat Jesper Arvenberg STAD:s dom idag i ”Propulsion-målet”.</p>
<p>– Daniel Redén är oerhört lättad och STAD kom fram till att han egentligen inte gjort något fel. Man säger inte hur han skulle kunnat säkerställa det här och man kommer också fram till att han inte ska få någon påföljd. Klart att Daniel är oerhört glad över det beskedet, säger Jesper Arvenberg.</p>
<h2>26 september 2021:</h2>
<p>Sulkysport bad advokat Mats Müllern att kommentera domen mot Daniel Redén och kallar den för <a href="https://sulkysport.se/debatt/en-logisk-kullerbytta/" target="_blank" rel="noopener">”en logisk kullerbytta”</a> och anser att ST borde ta eget ansvar och inte gjort Redén till en måltavla.</p>
<h2>1 november 2021:</h2>
<figure id="attachment_226426" aria-describedby="caption-attachment-226426" style="width: 617px" class="wp-caption aligncenter"><a href="https://sulkysport.se/wp-content/uploads/2021/10/mariacroon.jpg"><img class="size-sulky-mellan2 wp-image-226426" src="https://sulkysport.se/wp-content/uploads/2021/10/mariacroon-617x333.jpg" alt="" width="617" height="333" /></a><figcaption id="caption-attachment-226426" class="wp-caption-text">Maria Croon. Foto Mathias Hedlund/Sulkysport</figcaption></figure>
<p>Både Daniel Redén och Svenskt Travsport har <a href="https://sulkysport.se/st-overklagar-propulsion-dom/" target="_blank" rel="noopener">överklagat avgörandet</a> i Svensk Travsports Ansvarsnämnd (STAD) till travsportens överdomstol gällande ”Propulsion-affären”.</p>
<p>– Om vi inte skulle göra det så står STAD:s beslut fast och med en anslutningsöverklagan har Svensk Travsport möjlighet att lyfta och utveckla principiella frågeställningar kring det strikta tränaransvaret, säger Maria Croon, vd Svensk Travsport.</p>
<h2>3 december 2021:</h2>
<figure id="attachment_203594" aria-describedby="caption-attachment-203594" style="width: 617px" class="wp-caption aligncenter"><a href="https://sulkysport.se/wp-content/uploads/2021/08/sheldonkennedym7di2fvgrl4unsplash-scaled.jpg"><img class="wp-image-203594 size-sulky-mellan2" src="https://sulkysport.se/wp-content/uploads/2021/08/sheldonkennedym7di2fvgrl4unsplash-617x411.jpg" alt="" width="617" height="411" /></a><figcaption id="caption-attachment-203594" class="wp-caption-text">Stängda dörrar var det vid STAD:s förhandling, medan överdomstolen inte väljer att ha lyckta dörrar. Foto: Sheldon Kennedy</figcaption></figure>
<p><a href="https://sulkysport.se/oppen-forhandling-i-overdomstolen/" target="_blank" rel="noopener">Förhandlingen i överdomstolen blir ”öppen”</a>, vilket inte skedde i Svensk Travsports Ansvarsnämnd (STAD).</p>
<p>– Till skillnad mot STAD är vi av den uppfattningen att det inte finns någon anledning till att ha den här förhandlingen inför lyckta dörrar, säger överdomstolens ordförande Olle Sohlberg, som också berättar att ST inte längre påstår att det Daniel Redén inte längre står anklagad för oaksamhet utan endast gör gällande ”strikt ansvar.”</p>
<h2>6 december 2021:</h2>
<p>Förhandlingarna i överdomstolenn den 15-16 december <a href="https://sulkysport.se/propulsion-forhandling-uppskjuten/" target="_blank" rel="noopener">skjuts upp</a> och flyttas på obestämd tid på grund av coronaviruset. Enligt överdomstolens uppfattning – skriver Svensk Travsport – finns alltför många okända smittorisker med omikronvarianten av coronaviruset.</p>
<h2>23 december 2021:</h2>
<p>Franska travförbundet skriver i <a href="https://sulkysport.se/propulsion-tappar-593-600-euro/" target="_blank" rel="noopener">Bullentin</a> att Propulsion diskas i alla starter i Frankrike och att alla pengar – 593.600 euro – ska återbetalas, vilket också är reglerat när det publiceras i Bullentin.</p>
<h2>20 januari 2022:</h2>
<p><a href="https://sulkysport.se/st-betalar-ut-propulsion-pengar/" target="_blank" rel="noopener">Stall Zet betalar</a> in de prispengar – 155.000 euro – som Propulsion tjänade i sina två starter i Finlandia-Ajo och som styrelsen i finska travförbundet Suomen Hippos beslutade att återkräva sommaren 2021.</p>
<h2>21 februari 2022:</h2>
<figure id="attachment_277313" aria-describedby="caption-attachment-277313" style="width: 617px" class="wp-caption aligncenter"><a href="https://sulkysport.se/wp-content/uploads/2022/03/mattbotsfordoklqgsct8qsunsplash-scaled.jpg"><img class="size-sulky-mellan2 wp-image-277313" src="https://sulkysport.se/wp-content/uploads/2022/03/mattbotsfordoklqgsct8qsunsplash-617x347.jpg" alt="" width="617" height="347" /></a><figcaption id="caption-attachment-277313" class="wp-caption-text">Problem med ljudupptagning i STAD innebär att vittnen måste höras om i överdomstolen. Foto: Matt Botsford</figcaption></figure>
<p>Efter att förhandlingarna i Propulsion-målet skjutits upp på grund av corona har överdomstolen beslutat att hålla <a href="https://sulkysport.se/klart-for-forhandling/" target="_blank" rel="noopener">förhandlingar i Hästsportens Hus den 23-24 mars</a>. Vidare berättades att personer som hördes i Svensk Travsports Ansvarsnämnd (STAD) kommer att höras om.</p>
<p>– För det första redovisade inte STAD i sitt beslut vad folk har sagt. Det är ingen kritik utan bara ett konstaterande. På en del ställen gällande upptagningen av förhören i STAD och vad olika människor sagt, är det för mycket prassel vid sidan av och det går inte att höra vad folk säger. Då bestämde vi helt enkelt att vi tar upp all muntlig bevisning igen, säger överdomstolens ordförande Olle Sohlberg.</p>
<h2>4 mars 2022:</h2>
<p>Det italienska jordbruksdepartementet Mipaaf beslutade att Propulsion även fortsättningsvis <a href="https://sulkysport.se/gront-ljus-for-propulsion/" target="_blank" rel="noopener">får verka som avelshingst</a> trots att han inte längre uppfyller ställa krav (Grupp I-seger/prispengar) för att verka som avelshingst i Italien sedan Svensk Travsport (och senare Finland och Frankrike) fråndömts drygt 26 miljoner kronor och konfiskerats hans Grupp I-triumfer.</p>
<h2>9 mars 2022:</h2>
<p>Dansk Travsports Centralförbund beslutade att Propulsion skulle <a href="https://sulkysport.se/danmark-ja-till-propulsion/" target="_blank" rel="noopener">få fortsätta betäcka i Danmark</a> under 2022. Han är därmed godkänd för avel 2022 i Belgien, Danmark, Finland, Holland, Italien, Kanada, Tyskland och USA.</p>
<h2>23 mars 2022:</h2>
<p>Förhandlingarna i överdomstolen i Propulsion-målet startar och ska pågå i två dagar.</p>
<blockquote class="wp-embedded-content" data-secret="QOjAxgzYri"><p><a href="https://sulkysport.se/alla-tider-i-propulsion-malet/">Alla tider i Propulsion-målet</a></p></blockquote>
<p><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Alla tider i Propulsion-målet” &ndash; Sulkysport" src="https://sulkysport.se/alla-tider-i-propulsion-malet/embed/#?secret=TikxjuEFkP#?secret=QOjAxgzYri" data-secret="QOjAxgzYri" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe></p>
