<p><span class="anfang">S</span>vensk Travsports manövrerande för att försöka hitta rätt kompassriktning i den alltid lika brännande heta frågan om hur kuskarna beter sig när de finishkör – i dagligt tal driver – hästarna går ”sådär”. Det är komplext och svårt att förstå varför saker är som de är i grunden. Och ST gör det inte lättare.</p>
<p>Vi har nyss upplevt ett halvt dygn då <strong>Oskar Kylin Blom</strong>, med över 600 körda lopp förra året, varit högst upp på varenda svensk travsajt med stora rubriker. <em>”Avstängd tre månader”</em>. <em>”Avstängd tills vidare”</em>. Kylin Blom, med Gävle som hemmabana, fick många telefonsamtal från media att svara på, när han var på väg från Gotland till fastlandet efter att ha kört lopp på Visbytravet igår kväll.</p>
<p>Kylin Blom tyckte själv att han absolut inte gjort något fel. Visbytravets domare hade heller inte sett något fel i hur han körde <strong>Dino Dollar</strong> i gårdagkvällens sjätte lopp. Tittar man på löpningsfilmen skulle Kylin Bloms sätt att köra kunna vara skolexempel på vad som är en vårdad och återhållsam drivning, helt i linje med reglementets intentioner.</p>
<p>Men avstängd tre månader – nej rättare, avstängd tills vidare – blev han. Detta efter ingripande från banveterinären som larmades om att när Dino Dollar kom tillbaka efter loppet och duschades, så fanns där ett märke i hästens hud på vänstersidan. Ett märke som enligt banveterinären endast kunde ha uppkommit under de få minuter Oskar Kylin Blom satt bakom hästen, före, under och efter loppet och som påstås måste ha varit resultatet av att hästen fått ”en smäll” av sin kusk.</p>
<p>Var, när hur den påstådda smällen utdelades, får vi aldrig reda på. Filmerna från loppet visar inget. Inga vittnesuppgifter finns om hur märket kan ha uppstått. Oskar Kylin Blom har enligt vad han säger själv ingen aning om hur, när, var det kan ha hänt. Men plötsligt var han föremål för stora svarta rubriker: <em>”Avstängd tre månader”</em>. <em>”Avstängd tills vidare”</em>. <em>”Obegriplig avstängning!”,</em> var för övrigt Sulkysports rubrik.</p>
<p> </p>
<p><span class="anfang">E</span>n av de människor som befolkar ett av landets domartorn skrev, efter att Svensk Travsport under fredagförmiddagen fastställt påföljden för det där märket till 3.000 kronor i böter och sex dagars avstängning, ett meddelande till mig: <em>”Nu måste väl alla kuskar noga börja kolla sina hästar innan de kör ut till ett lopp. Det blir ungefär som när man ska hämta ut en hyrbil; lyder man inte uppmaningen att kolla så det inte finns några märken eller repor i lacken innan man kör iväg kan det bli dyrt när bilen ska lämnas tillbaka”.</em></p>
<p>Underförstått blir att denna domare, utifrån den löpningsfilm som finns på atg.se, alltså inte trodde att det var OKB som åstadkommit ”märket” på Dino Dollar, utan att det kan/bör ha funnits där innan. Men som kusk/hyrbilsförare är du alltid ansvarig om det finns en lackskada som inte dokumenterats i handlingarna innan uthyrningen började, när du kommer tillbaka för att lämna ifrån dig hästen/bilen. Att råka ut för det känns givetvis oerhört surt, men ur ”rättslig och försäkringsmässig” synvinkel finns det ingen tvekan om att det måste vara på det sättet. Det är bara att ”ta smällen” – både som hyrkusk och bilhyrare.</p>
<p> </p>
<p><span class="anfang">M</span>en åter till den övergripande frågan; att Svensk Travsport inte lyckas speciellt väl med att skapa förståelse för hur drivningar och finishkörningar döms där det synes uppstå märken på hästarna (vilket givetvis inte får/ska ske) och det här ”regelbrottsfältet” synes utifrån som fjärran från likhet inför lagen. Dessutom – vågar jag påstå – är man på Svensk Travsport långt ifrån nöjd med att en händelse som den på Visbytravet igår skapar stora svarta rubriker i media; även om rubrikerna förvisso stannar inom den ”lilla travbubblan” i det stora medlabruset. Men där får ST helt och hållet skylla sig självt.</p>
<p><a href="https://sulkysport.se/wp-content/uploads/2020/07/skarmavbild20200723kl.22.22.00.png"><img class="size-full wp-image-101841 aligncenter" src="https://sulkysport.se/wp-content/uploads/2020/07/skarmavbild20200723kl.22.22.00.png" alt="" width="1974" height="164" /></a></p>
<p>Varför då? Jo, för att Svensk Travsport lyckas inte korrekt hantera vad som i idrottsvärlden ska vara det sakligaste och faktamässigt renodlade. Resultatlistan. Nu skrev man från början ut <em>”avstängning 200723-201023”</em> och eftersom det står på en officiell resultatlista måste det ju då vara så. Men icke när det gäller Svensk Travsport. Avstängningen i sådana här fall träder i kraft omedelbums och gäller ”tills vidare”. Men det finns det ingen rutin för att mata in i resultatdatan!</p>
<blockquote><p>Svensk Travsport lyckas inte korrekt hantera vad som i idrottsvärlden ska vara det sakligaste och faktamässigt renodlade</p></blockquote>
<p>Jo, ni läste rätt. Det är 2020 och ATG/ST har tillsammans lagt miljoners miljarder på de datasystem som används. Men någon rutin för att göra korrekta resultatlisterapporteringar när kuskar blir direktavstängda finns inte. Det är okej att baxna över det faktumet.</p>
<p> </p>
<p><span class="anfang">S</span>annolikt kommer den här företeelsen att öka. Det är nämligen uppenbart att det har börjat kollas fler hästar efter loppen än tidigare, av banveterinärer och funktionärer. Vilket förstås är alldeles utmärkt och helt i linje med att förbättra hästhälsan och respekten för djuren när vi människor nu förbehåller oss rätten att tävla med hästar på ett sådant sätt att de springer sig olika grader av trötta och ska förmås att öka/hålla farten sista biten in mot mål.</p>
<p>Och den som söker – han finner såklart. Oskar Kylin Blom/Dino Dollar är det tredje uppmärksammade fallet bara under juli som ST:s domarbas <strong>Jonny Staf</strong> fått att hantera. Lägg till det två fall till av enhandsdrivningar under försommaren och en i princip varvslång drivning av en trög häst i ett breddlopp på vårvintern som resulterade i tolv veckors avstängning för kusken. Till det kommer ett fall i Boden där en ganska enig ”publikdomarkår” tyckte att den aktuella kusken kom alldeles för billigt undan. Det loppet hänsköts nämligen inte till ST utan dömdes av Bodens måldomarnämnd själv.</p>
<p> </p>
<p><span class="anfang">D</span>et är någonstans nu vi börjar stängsla in problematiken. Att det här hamnar hos ST gång efter annan och inte döms direkt, och lokalt.</p>
<p>Det som synes komplicera är att utöver domarnas arbete finns en överordnad faktor vars ord i princip är lag: Banveterinärerna. De som är tillsatta på uppdrag av staten (Jordbruksverket) att bevaka hästarnas hälsa, välmående och intresse i samband med travtävlingar. Att banveterinärers ord är lag är inte bara en klyscha; banveterinärerna ska bokstavligt talat bevaka att det inte bryts mot djurskyddslagen när hästar tävlar, och ingripa om misstanke finns om att så sker.</p>
<p>Måldomare och banveterinärer förväntas samverka, men det är inte alltid så lätt som det kanske låter. Måldomarna ska ju förhålla sig till tävlingsreglementet. Banveterinärerna alltså till djurskyddslagen. Och ST försöker föga förvånande vara proaktivt och ”klappa på med hårdare påföljd” när något händer som initierat av banveterinärer också kan sluta i en rättssal någon gång i framtiden i det överbelastade rättssystemet.</p>
<p> </p>
<p><span class="anfang">D</span>ärför kan det bli så här konstigt:</p>
<p>Norske kusken <strong>Anders Wolden Lundström</strong> skickade på sin häst <strong>Fougueux</strong> ”så mycket” på upploppet i ett lopp i Årjäng i mitten på juli att påföljden ”dubbel C” (vilket i Wolden Lundströms fall med bara några tiotal körda lopp per blev 3.000 kronor i böter och och fyra veckors avstängning), som dagen efter loppet sattes efter att även den händelsen genererat stora svarta rubriker i både svensk och norsk travmedia, kändes billig.</p>
<p>Samma vecka hade <strong>Pierre Nyström</strong> gått en bra bit över gränsen för vad som är tillåtet körspösvingande sista 200 meterna med <strong>Timo Lane</strong> i en segerstrid i Eskilstuna. Nyström blev avstängd i tolv veckor. Men inte av Sundbyholms måldomare, utan av Svensk Travsports tjänstemän (domarbasen Jonny Staf). Eftersom Nyström kör mer än dubbelt så många lopp som Wolden Lundström kan Nyströms påföljd sägas ha blivit sex gånger så hård. För två väldigt likartade drivningsregelbrott.</p>
<p>Varför blir det så? Jo, för att banveterinären fann märken efter loppet på Timo Lane som synes ha sitt ursprung i kuskens körspöhantering medan det på Fougueux inte hittades några märken alls.</p>
<p>Och så kom då Oskar Kylin Blom/Dino Dollar igår. Där ingen levande människa kan se att kusken gjorde något som helst otillåtet under loppet, men där Oskars sex dagars avstängning, med hänsyn till att han kör så många lopp som 600 per år, ändå görs påföljdsmässigt likadan (dubbel C) med Anders Wolden Lundströms (gravt otillåtna) finishkörning i Årjäng. Och anledningen till att Kylin Blom över huvud taget ömdes till en avstängning var att banveterinärens uppmärksamhet påkallades avseende ett märke på hästen – domarna hade ju inte sett kusken begå något regelbrott.</p>
<p> </p>
<p><span class="anfang">D</span>et är som sagt verkligen inte lätt detta.</p>
<p>Men ST kan göra en del för att trots allt göra det lättare.</p>
<p>Det enklaste är förstås att snabbt som sjutton lösa det där som måste vara busenkelt datatekniskt; en rutin för hur <em>”omedelbar direktavstängning”</em> matas in i sportdatasystemet så ST kan sluta sprida en massa förvirring om tremånadersavstängningar som inte alls är tre månader.</p>
<p>Det andra är att måldomarna ska kunna klara att döma sånt här själva, och direkt i anslutning till när regelbrottet begåtts. Det ska inte behöva sitta centrala funktioner på Svensk Travsport och döma vad kuskar gjort i lopp dagen innan utan det måste kunna hanteras lokalt.</p>
<p>Åtminstone i steg ett. När det är allvarliga förseelser lär påföljderna sättas så högt att de blir överklagningsbara, och då är det ju upp till kusken om denne vill överpröva det denne dömts till. Då blir det ST:s Överdomstol som kommer in i bilden; inte tjänstemän på det centrala kansliet. Tjänstemännens definitionsmässiga funktion ska vara att ta fram beslutsunderlag till den kommitté som sätter reglerna, utbilda och fortbilda domarna, och till ÖD förbereda/handlägga ärenden som överklagas dit.</p>
<blockquote><p>måldomarna ska kunna klara att döma sånt här själva</p></blockquote>
<p>ST:s tjänstemän i Hästsportens hus ska däremot inte sitta och operativt döma kuskar för vad som händer i travlopp på någon bana, vilken det än vara må, ute i landet! Det är faktiskt måldomarnämndernas jobb att göra det.</p>
<blockquote class="wp-embedded-content" data-secret="RsQQZzKA1m"><p><a href="https://sulkysport.se/sex-dagars-avstangning-for-kylin-blom/">Sex dagars avstängning för Kylin Blom</a></p></blockquote>
<p><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Sex dagars avstängning för Kylin Blom” &ndash; Sulkysport" src="https://sulkysport.se/sex-dagars-avstangning-for-kylin-blom/embed/#?secret=0csJZYkQL0#?secret=RsQQZzKA1m" data-secret="RsQQZzKA1m" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe></p>
<blockquote class="wp-embedded-content" data-secret="jMSXar854n"><p><a href="https://sulkysport.se/att-det-ska-ha-blivit-ett-marke-kanns-omojligt/">”Att det ska ha blivit ett märke känns omöjligt”</a></p></blockquote>
<p><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="””Att det ska ha blivit ett märke känns omöjligt”” &ndash; Sulkysport" src="https://sulkysport.se/att-det-ska-ha-blivit-ett-marke-kanns-omojligt/embed/#?secret=RADzzheoSv#?secret=jMSXar854n" data-secret="jMSXar854n" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe></p>
<blockquote class="wp-embedded-content" data-secret="tioKWIvZN7"><p><a href="https://sulkysport.se/obegriplig-avstangning/">Obegriplig avstängning!</a></p></blockquote>
<p><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Obegriplig avstängning!” &ndash; Sulkysport" src="https://sulkysport.se/obegriplig-avstangning/embed/#?secret=Vo78XJxHxZ#?secret=tioKWIvZN7" data-secret="tioKWIvZN7" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe></p>
<blockquote class="wp-embedded-content" data-secret="FLFOAomJ6U"><p><a href="https://sulkysport.se/lundstrom-woldens-forseelse-nedgraderad/">Lundström Woldens förseelse nedgraderad</a></p></blockquote>
<p><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Lundström Woldens förseelse nedgraderad” &ndash; Sulkysport" src="https://sulkysport.se/lundstrom-woldens-forseelse-nedgraderad/embed/#?secret=k0WchJR8l3#?secret=FLFOAomJ6U" data-secret="FLFOAomJ6U" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe></p>
<blockquote class="wp-embedded-content" data-secret="DjAS1R5ruH"><p><a href="https://sulkysport.se/norsk-proffstranare-direktavstangd-for-drivning/">Norsk proffstränare direktavstängd för drivning</a></p></blockquote>
<p><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Norsk proffstränare direktavstängd för drivning” &ndash; Sulkysport" src="https://sulkysport.se/norsk-proffstranare-direktavstangd-for-drivning/embed/#?secret=Gnfpm3jlib#?secret=DjAS1R5ruH" data-secret="DjAS1R5ruH" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe></p>
<blockquote class="wp-embedded-content" data-secret="qGb7nIhgAy"><p><a href="https://sulkysport.se/tre-manaders-avstangning/">Tolv veckors avstängning</a></p></blockquote>
<p><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Tolv veckors avstängning” &ndash; Sulkysport" src="https://sulkysport.se/tre-manaders-avstangning/embed/#?secret=weYKAnjFi0#?secret=qGb7nIhgAy" data-secret="qGb7nIhgAy" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe></p>
<blockquote class="wp-embedded-content" data-secret="HeNDP4lwMt"><p><a href="https://sulkysport.se/avstangd-med-omedelbar-verkan/">Avstängd med omedelbar verkan</a></p></blockquote>
<p><iframe class="wp-embedded-content" sandbox="allow-scripts" security="restricted" style="position: absolute; visibility: hidden;" title="”Avstängd med omedelbar verkan” &ndash; Sulkysport" src="https://sulkysport.se/avstangd-med-omedelbar-verkan/embed/#?secret=3Knb2cxtJy#?secret=HeNDP4lwMt" data-secret="HeNDP4lwMt" width="500" height="282" frameborder="0" marginwidth="0" marginheight="0" scrolling="no"></iframe></p>
